unsigned int check_nondom(unsigned int i) /* Check for feasibility and nondomination of particles in pop and archive */
{
unsigned int sum, h = 0, j;//, cont;
double archiveCons[maxvar], popCons[maxvar];
do
{
sum = 0;
//cont = 0;
for(j=0; j < maxvar; j++)
{
archiveCons[j] = archiveVar[h][j];
popCons[j] = popVar[i][j];
}
/* Si la particula en el archivo tiene menos restricciones violadas */
if(check_constraints(archiveCons) < check_constraints(popCons))
return 0;
/* Si la particula tiene mas restriccion, eliminar*/
if(check_constraints(archiveCons) > check_constraints(popCons))
{
for(j = 0; j < maxvar; j++)
archiveVar[h][j] = archiveVar[nondomCtr-1][j];
for(j = 0; j < maxfun; j++)
archiveFit[h][j] = archiveFit[nondomCtr-1][j];
nondomCtr -= 1;
}
else /*Si tienen las mismas violacion de restricciones*/
{
for(j = 0; j < maxfun; j++)
{
if( ((archiveFit[h][j] < popFit[i][j]) && (optimization == 0)) || ((archiveFit[h][j] > popFit[i][j]) && (optimization == 1)))
sum += 1;
// if( archiveFit[h][j] == popFit[i][j])
// cont += 1;
}
if(sum == maxfun)// || cont == maxfun) /* Si la particula en el archio es dominada */
return 0;
else if(sum == 0)
{ /* Si la particula en el archivo es domianda borrar *///Revisar
for(j = 0; j < maxvar; j++)
archiveVar[h][j] = archiveVar[nondomCtr-1][j];
for(j = 0; j < maxfun; j++)
archiveFit[h][j] = archiveFit[nondomCtr-1][j];
nondomCtr -= 1;
}
else
{
h += 1;
}
}
} while(h < nondomCtr);
return 1;
}
static int
replace_values( Operation *op, Entry *e, Modification *mod, int *newlevel )
{
int rc;
if ( mod->sm_values != NULL ) {
*newlevel = 0;
rc = check_constraints( mod, newlevel );
if ( rc != LDAP_SUCCESS ) {
return rc;
}
}
rc = attr_delete( &e->e_attrs, mod->sm_desc );
if ( rc != LDAP_SUCCESS && rc != LDAP_NO_SUCH_ATTRIBUTE ) {
return rc;
}
if ( mod->sm_values != NULL ) {
rc = attr_merge_normalize( e, mod->sm_desc, mod->sm_values,
op->o_tmpmemctx );
if ( rc != LDAP_SUCCESS ) {
return rc;
}
}
return LDAP_SUCCESS;
}
static bool check_type_params(ast_t** astp)
{
ast_t* lhs = *astp;
ast_t* type = ast_type(lhs);
if(is_typecheck_error(type))
return false;
ast_t* typeparams = ast_childidx(type, 1);
assert(ast_id(type) == TK_FUNTYPE);
if(ast_id(typeparams) == TK_NONE)
return true;
BUILD(typeargs, typeparams, NODE(TK_TYPEARGS));
if(!check_constraints(typeparams, typeargs, true))
{
ast_free_unattached(typeargs);
return false;
}
type = reify(type, typeparams, typeargs);
typeparams = ast_childidx(type, 1);
ast_replace(&typeparams, ast_from(typeparams, TK_NONE));
REPLACE(astp, NODE(ast_id(lhs), TREE(lhs) TREE(typeargs)));
ast_settype(*astp, type);
return true;
}
void process_ibpage(page_t *page) {
ulint page_id;
rec_t *origin;
ulint offsets[MAX_TABLE_FIELDS + 2];
ulint offset, i;
// Skip tables if filter used
if (use_filter_id) {
dulint index_id = mach_read_from_8(page + PAGE_HEADER + PAGE_INDEX_ID);
if (index_id.low != filter_id.low || index_id.high != filter_id.high) {
if (debug) {
page_id = mach_read_from_4(page + FIL_PAGE_OFFSET);
printf("Skipped using index id filter: %lu!\n", page_id);
}
return;
}
}
// Read page id
page_id = mach_read_from_4(page + FIL_PAGE_OFFSET);
if (debug) printf("Page id: %lu\n", page_id);
// Check requested and actual formats
if (!check_page_format(page)) return;
// Find possible data area start point (at least 5 bytes of utility data)
offset = 100 + record_extra_bytes;
if (debug) printf("Starting offset: %lu. Checking %d table definitions.\n", offset, table_definitions_cnt);
// Walk through all possible positions to the end of page
// (start of directory - extra bytes of the last rec)
while (offset < UNIV_PAGE_SIZE - record_extra_bytes) {
// Get record pointer
origin = page + offset;
if (debug) printf("\nChecking offset: %lu: ", offset);
// Check all tables
for (i = 0; i < table_definitions_cnt; i++) {
// Get table info
table_def_t *table = &(table_definitions[i]);
if (debug) printf(" (%s) ", table->name);
// Check if origin points to a valid record
if (check_for_a_record(page, origin, table, offsets) && check_constraints(origin, table, offsets)) {
if (debug) printf("\n---------------------------------------------------\n"
"PAGE%lu: Found a table %s record: %p (offset = %lu)\n", page_id, table->name, origin, offset);
offset += process_ibrec(page, origin, table, offsets);
break;
}
}
// Check from next byte
offset++;
}
}
bool
solver_naive(Solver *self)
{
int round = 0;
while (true) {
const bool more = next_world(self);
const bool passed = check_constraints(self->values,
self->constraints, self->n_constraints);
printf("round=%d more=%s passed=%s\n",
round, (more) ? "TRUE" : "FALSE", (passed) ? "TRUE" : "FALSE");
round += 1;
if (!more) break;
if (passed) return true;
}
return false;
}
bool expr_nominal(pass_opt_t* opt, ast_t** astp)
{
// Resolve typealiases and typeparam references.
if(!names_nominal(opt, *astp, astp))
return false;
ast_t* ast = *astp;
switch(ast_id(ast))
{
case TK_TYPEPARAMREF:
return flatten_typeparamref(ast) == AST_OK;
case TK_NOMINAL:
break;
default:
return true;
}
// If still nominal, check constraints.
ast_t* def = (ast_t*)ast_data(ast);
// Special case: don't check the constraint of a Pointer. This allows a
// Pointer[Pointer[A]], which is normally not allowed, as a Pointer[A] is
// not a subtype of Any.
ast_t* id = ast_child(def);
const char* name = ast_name(id);
if(!strcmp(name, "Pointer"))
return true;
ast_t* typeparams = ast_childidx(def, 1);
ast_t* typeargs = ast_childidx(ast, 2);
return check_constraints(typeargs, typeparams, typeargs, true);
}
// requires: exp be a c string, with no
// spaces and only valid characters.
int rpn(char *exp, int size) {
if (size == 1) {
return 0;
} else {
if (check_constraints(exp, size)) {
printf("%s\n", exp);
printf("Constraints not met\n");
return 1;
}
int delim_loc = get_delim(exp, size);
char delim = exp[delim_loc];
exp[delim_loc] = '\0';
exp[size - 1] = '\0';
char *left, *right;
left = exp + 1;
right = exp + delim_loc + 1;
if (rpn(left, strlen(left)) ||
rpn(right, strlen(right))) {
return 1;
}
merge(exp, left, right, delim);
return 0;
}
}
bool expr_nominal(pass_opt_t* opt, ast_t** astp)
{
// Resolve type aliases and typeparam references.
if(!names_nominal(opt, *astp, astp, true))
return false;
ast_t* ast = *astp;
switch(ast_id(ast))
{
case TK_TYPEPARAMREF:
return flatten_typeparamref(ast) == AST_OK;
case TK_NOMINAL:
break;
default:
return true;
}
// If still nominal, check constraints.
ast_t* def = (ast_t*)ast_data(ast);
// Special case: don't check the constraint of a Pointer. This allows a
// Pointer[Pointer[A]], which is normally not allowed, as a Pointer[A] is
// not a subtype of Any.
ast_t* id = ast_child(def);
const char* name = ast_name(id);
if(!strcmp(name, "Pointer"))
return true;
ast_t* typeparams = ast_childidx(def, 1);
ast_t* typeargs = ast_childidx(ast, 2);
if(!reify_defaults(typeparams, typeargs, true))
return false;
if(!strcmp(name, "MaybePointer"))
{
// MaybePointer[A] must be bound to a struct.
assert(ast_childcount(typeargs) == 1);
ast_t* typeparam = ast_child(typeparams);
ast_t* typearg = ast_child(typeargs);
bool ok = false;
switch(ast_id(typearg))
{
case TK_NOMINAL:
{
ast_t* def = (ast_t*)ast_data(typearg);
ok = ast_id(def) == TK_STRUCT;
break;
}
case TK_TYPEPARAMREF:
{
ast_t* def = (ast_t*)ast_data(typearg);
ok = def == typeparam;
break;
}
default: {}
}
if(!ok)
{
ast_error(ast,
"%s is not allowed: the type argument to MaybePointer must be a struct",
ast_print_type(ast));
return false;
}
}
return check_constraints(typeargs, typeparams, typeargs, true);
}
bool expr_nominal(pass_opt_t* opt, ast_t** astp)
{
// Resolve type aliases and typeparam references.
if(!names_nominal(opt, *astp, astp, true))
return false;
ast_t* ast = *astp;
switch(ast_id(ast))
{
case TK_TYPEPARAMREF:
return flatten_typeparamref(opt, ast) == AST_OK;
case TK_NOMINAL:
break;
default:
return true;
}
// If still nominal, check constraints.
ast_t* def = (ast_t*)ast_data(ast);
// Special case: don't check the constraint of a Pointer or an Array. These
// builtin types have no contraint on their type parameter, and it is safe
// to bind a struct as a type argument (which is not safe on any user defined
// type, as that type might then be used for pattern matching).
if(is_pointer(ast) || is_literal(ast, "Array"))
return true;
ast_t* typeparams = ast_childidx(def, 1);
ast_t* typeargs = ast_childidx(ast, 2);
if(!reify_defaults(typeparams, typeargs, true, opt))
return false;
if(is_maybe(ast))
{
// MaybePointer[A] must be bound to a struct.
assert(ast_childcount(typeargs) == 1);
ast_t* typeparam = ast_child(typeparams);
ast_t* typearg = ast_child(typeargs);
bool ok = false;
switch(ast_id(typearg))
{
case TK_NOMINAL:
{
ast_t* def = (ast_t*)ast_data(typearg);
ok = ast_id(def) == TK_STRUCT;
break;
}
case TK_TYPEPARAMREF:
{
ast_t* def = (ast_t*)ast_data(typearg);
ok = def == typeparam;
break;
}
default: {}
}
if(!ok)
{
ast_error(opt->check.errors, ast,
"%s is not allowed: "
"the type argument to MaybePointer must be a struct",
ast_print_type(ast));
return false;
}
return true;
}
return check_constraints(typeargs, typeparams, typeargs, true, opt);
}
int nx842_crypto_decompress(struct crypto_tfm *tfm,
const u8 *src, unsigned int slen,
u8 *dst, unsigned int *dlen)
{
struct nx842_crypto_ctx *ctx = crypto_tfm_ctx(tfm);
struct nx842_crypto_header *hdr;
struct nx842_crypto_param p;
struct nx842_constraints c = *ctx->driver->constraints;
int n, ret, hdr_len;
u16 ignore = 0;
check_constraints(&c);
p.in = (u8 *)src;
p.iremain = slen;
p.out = dst;
p.oremain = *dlen;
p.ototal = 0;
*dlen = 0;
hdr = (struct nx842_crypto_header *)src;
spin_lock_bh(&ctx->lock);
/* If it doesn't start with our header magic number, assume it's a raw
* 842 compressed buffer and pass it directly to the hardware driver
*/
if (be16_to_cpu(hdr->magic) != NX842_CRYPTO_MAGIC) {
struct nx842_crypto_header_group g = {
.padding = 0,
.compressed_length = cpu_to_be32(p.iremain),
.uncompressed_length = cpu_to_be32(p.oremain),
};
ret = decompress(ctx, &p, &g, &c, 0);
if (ret)
goto unlock;
goto success;
}
if (!hdr->groups) {
pr_err("header has no groups\n");
ret = -EINVAL;
goto unlock;
}
if (hdr->groups > NX842_CRYPTO_GROUP_MAX) {
pr_err("header has too many groups %x, max %x\n",
hdr->groups, NX842_CRYPTO_GROUP_MAX);
ret = -EINVAL;
goto unlock;
}
hdr_len = NX842_CRYPTO_HEADER_SIZE(hdr->groups);
if (hdr_len > slen) {
ret = -EOVERFLOW;
goto unlock;
}
memcpy(&ctx->header, src, hdr_len);
hdr = &ctx->header;
for (n = 0; n < hdr->groups; n++) {
/* ignore applies to last group */
if (n + 1 == hdr->groups)
ignore = be16_to_cpu(hdr->ignore);
ret = decompress(ctx, &p, &hdr->group[n], &c, ignore);
if (ret)
goto unlock;
}
success:
*dlen = p.ototal;
pr_debug("decompress total slen %x dlen %x\n", slen, *dlen);
ret = 0;
unlock:
spin_unlock_bh(&ctx->lock);
return ret;
}
EXPORT_SYMBOL_GPL(nx842_crypto_decompress);
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("IBM PowerPC Nest (NX) 842 Hardware Compression Driver");
MODULE_AUTHOR("Dan Streetman <*****@*****.**>");
int nx842_crypto_compress(struct crypto_tfm *tfm,
const u8 *src, unsigned int slen,
u8 *dst, unsigned int *dlen)
{
struct nx842_crypto_ctx *ctx = crypto_tfm_ctx(tfm);
struct nx842_crypto_header *hdr = &ctx->header;
struct nx842_crypto_param p;
struct nx842_constraints c = *ctx->driver->constraints;
unsigned int groups, hdrsize, h;
int ret, n;
bool add_header;
u16 ignore = 0;
check_constraints(&c);
p.in = (u8 *)src;
p.iremain = slen;
p.out = dst;
p.oremain = *dlen;
p.ototal = 0;
*dlen = 0;
groups = min_t(unsigned int, NX842_CRYPTO_GROUP_MAX,
DIV_ROUND_UP(p.iremain, c.maximum));
hdrsize = NX842_CRYPTO_HEADER_SIZE(groups);
spin_lock_bh(&ctx->lock);
/* skip adding header if the buffers meet all constraints */
add_header = (p.iremain % c.multiple ||
p.iremain < c.minimum ||
p.iremain > c.maximum ||
(u64)p.in % c.alignment ||
p.oremain % c.multiple ||
p.oremain < c.minimum ||
p.oremain > c.maximum ||
(u64)p.out % c.alignment);
hdr->magic = cpu_to_be16(NX842_CRYPTO_MAGIC);
hdr->groups = 0;
hdr->ignore = 0;
while (p.iremain > 0) {
n = hdr->groups++;
ret = -ENOSPC;
if (hdr->groups > NX842_CRYPTO_GROUP_MAX)
goto unlock;
/* header goes before first group */
h = !n && add_header ? hdrsize : 0;
if (ignore)
pr_warn("internal error, ignore is set %x\n", ignore);
ret = compress(ctx, &p, &hdr->group[n], &c, &ignore, h);
if (ret)
goto unlock;
}
if (!add_header && hdr->groups > 1) {
pr_err("Internal error: No header but multiple groups\n");
ret = -EINVAL;
goto unlock;
}
/* ignore indicates the input stream needed to be padded */
hdr->ignore = cpu_to_be16(ignore);
if (ignore)
pr_debug("marked %d bytes as ignore\n", ignore);
if (add_header)
ret = nx842_crypto_add_header(hdr, dst);
if (ret)
goto unlock;
*dlen = p.ototal;
pr_debug("compress total slen %x dlen %x\n", slen, *dlen);
unlock:
spin_unlock_bh(&ctx->lock);
return ret;
}
void insert_nondom() /* Insertar particulas no dominadas en el archivo */
{
unsigned int i, j, k, total, insertFlag, bottom, cont;
double archiveCons[maxvar], popCons[maxvar];
for(i=0; i< popsize; i++)
{
if(nondomCtr == 0)
{ /* Si el archivo esta vacio */
/* Insertar la particula en el archivo */
for(j = 0; j < maxvar; j++)
archiveVar[nondomCtr][j] = popVar[i][j];
for(j = 0; j < maxfun; j++)
archiveFit[nondomCtr][j] = popFit[i][j];
nondomCtr += 1;
}
else
{ /* Si el archivo no esta vacio */
insertFlag = 1;
/*Para cada particula en el archivo */
for(k=0; k < nondomCtr; k++)
{
/* Primero, verificar si es factibe */
for(j=0; j < maxvar; j++)
{
popCons[j] = popVar[i][j];
archiveCons[j] = archiveVar[k][j];
}
/* Si ambas partculas no son factibles */
if((check_constraints(archiveCons) > 0) && (check_constraints(popCons) > 0))
{
delete_particle(k); /* Eliminar particula del archivo */
insertFlag = 0; /* No insertar la particula en la poblacion */
break;
}
else if(check_constraints(popCons) > 0)
{ /* Si la particula de la poblacion en infactible */
insertFlag = 0;/* No insertar la particula en la poblacion */
break;
}
else if(check_constraints(archiveCons) > 0)
{ /* Si la particula en el archivo es infactible */
delete_particle(k); /* Borrar la particula en el archivo */
if((nondomCtr != 0) || (k != nondomCtr-1))
k--;
continue;
}
/* Segundo, verificar dominancia*/
total = 0;
cont = 0;
/* Si ambos son factiblesf, vereficar no diminancia*/
for(j=0; j < maxfun; j++)
{
if(( (popFit[i][j] < archiveFit[k][j]) && (optimization == 0)) || (popFit[i][j] > archiveFit[k][j]) && (optimization == 1))
total += 1;
}
for(j=0; j < maxfun; j++)
{
if( (popFit[i][j] == archiveFit[k][j]))
{
cont ++; /* No insertar la particula en la poblacion */
insertFlag = 0;
}
}
if(total == maxfun || cont == maxfun) /* Si la particula es totalmente dominada */
delete_particle(k); /* Borrar particula del archivo*/
else if(total == 0)
{ /* Si la particula en dominada en el archivo*/
insertFlag = 0; /* No insertar la particula en la poblacion */
break;
}
} /* Termina la comparacion de una particula en la poblacion con el archivo */
}
/* Insertar la particula si es factible y no dominada */
if(insertFlag == 1)
{
/* Si la memoria no esta llena, insertar particula */
if (nondomCtr < archive_size)
{
for(j = 0; j < maxvar; j++)
archiveVar[nondomCtr][j] = popVar[i][j];
for(j = 0; j < maxfun; j++)
archiveFit[nondomCtr][j] = popFit[i][j];
nondomCtr += 1;
}
else
{ /* Calcular hipervolumen*/
bottom = (unsigned int)((nondomCtr-1) * 0.90);
/* Selecionar aleatoriamente un lugar para reemplazar */
k = RandomInt(bottom, nondomCtr-1);
/* Insertar nueva particula en el archivo */
for(j = 0; j < maxvar; j++)
archiveVar[k][j] = popVar[i][j];
for(j = 0; j < maxfun; j++)
archiveFit[k][j] = popFit[i][j];
}
}
} /* Termina la comparacion de particulas de la poblacion en el archivo */
}
void process_ibpage(page_t *page) {
ulint page_id;
rec_t *origin;
ulint offsets[MAX_TABLE_FIELDS + 2];
ulint offset, i;
int is_page_valid = 0;
int comp;
unsigned int expected_records = 0;
unsigned int actual_records = 0;
int16_t b, infimum, supremum;
// Skip tables if filter used
if (use_filter_id) {
dulint index_id = mach_read_from_8(page + PAGE_HEADER + PAGE_INDEX_ID);
if (index_id.low != filter_id.low || index_id.high != filter_id.high) {
if (debug) {
page_id = mach_read_from_4(page + FIL_PAGE_OFFSET);
printf("Skipped using index id filter: %lu!\n", page_id);
}
return;
}
}
// Read page id
page_id = mach_read_from_4(page + FIL_PAGE_OFFSET);
if (debug) printf("Page id: %lu\n", page_id);
fprintf(f_result, "-- Page id: %lu", page_id);
// Check requested and actual formats
if (!check_page_format(page)) return;
if(table_definitions_cnt == 0){
fprintf(stderr, "There are no table definitions. Please check include/table_defs.h\n");
exit(EXIT_FAILURE);
}
is_page_valid = check_page(page, &expected_records);
// comp == 1 if page in COMPACT format and 0 if REDUNDANT
comp = page_is_comp(page);
fprintf(f_result, ", Format: %s", (comp ) ? "COMPACT": "REDUNDANT");
infimum = (comp) ? PAGE_NEW_INFIMUM : PAGE_OLD_INFIMUM;
supremum = (comp) ? PAGE_NEW_SUPREMUM : PAGE_OLD_SUPREMUM;
// Find possible data area start point (at least 5 bytes of utility data)
if(is_page_valid){
b = mach_read_from_2(page + infimum - 2);
offset = (comp) ? infimum + b : b;
}
else{
offset = 100 + record_extra_bytes;
}
fprintf(f_result, ", Records list: %s", is_page_valid? "Valid": "Invalid");
fprintf(f_result, ", Expected records: (%u %lu)", expected_records, mach_read_from_2(page + PAGE_HEADER + PAGE_N_RECS));
fprintf(f_result, "\n");
if (debug) printf("Starting offset: %lu (%lX). Checking %d table definitions.\n", offset, offset, table_definitions_cnt);
// Walk through all possible positions to the end of page
// (start of directory - extra bytes of the last rec)
//is_page_valid = 0;
while (offset < UNIV_PAGE_SIZE - record_extra_bytes && ( (offset != supremum ) || !is_page_valid) ) {
// Get record pointer
origin = page + offset;
if (debug) printf("\nChecking offset: 0x%lX: ", offset);
// Check all tables
for (i = 0; i < table_definitions_cnt; i++) {
// Get table info
table_def_t *table = &(table_definitions[i]);
if (debug) printf(" (%s) ", table->name);
// Check if origin points to a valid record
if (check_for_a_record(page, origin, table, offsets) && check_constraints(origin, table, offsets)) {
actual_records++;
if (debug) printf("\n---------------------------------------------------\n"
"PAGE%lu: Found a table %s record: %p (offset = %lu)\n", \
page_id, table->name, origin, offset);
if(is_page_valid){
process_ibrec(page, origin, table, offsets);
b = mach_read_from_2(page + offset - 2);
offset = (comp) ? offset + b : b;
}
else{
offset += process_ibrec(page, origin, table, offsets);
}
if (debug) printf("Next offset: 0x%lX", offset);
break;
}
else{
if(is_page_valid){
b = mach_read_from_2(page + offset - 2);
offset = (comp) ? offset + b : b;
}
else{
offset++;
}
if (debug) printf("\nNext offset: %lX", offset);
}
}
}
fprintf(f_result, "-- Page id: %lu", page_id);
fprintf(f_result, ", Found records: %u", actual_records);
fprintf(f_result, ", Lost records: %s", (actual_records != expected_records) ? "YES": "NO");
fprintf(f_result, ", Leaf page: %s", (mach_read_from_2(page + PAGE_HEADER + PAGE_LEVEL) == 0)? "YES": "NO");
fprintf(f_result, "\n");
}
bool expr_qualify(pass_opt_t* opt, ast_t** astp)
{
// Left is a postfix expression, right is a typeargs.
ast_t* ast = *astp;
ast_t* left = ast_child(ast);
ast_t* right = ast_sibling(left);
ast_t* type = ast_type(left);
assert(ast_id(right) == TK_TYPEARGS);
if(is_typecheck_error(type))
return false;
switch(ast_id(left))
{
case TK_TYPEREF:
{
// Qualify the type.
assert(ast_id(type) == TK_NOMINAL);
if(ast_id(ast_childidx(type, 2)) != TK_NONE)
{
ast_error(ast, "can't qualify an already qualified type");
return false;
}
type = ast_dup(type);
ast_t* typeargs = ast_childidx(type, 2);
ast_replace(&typeargs, right);
ast_settype(ast, type);
ast_setid(ast, TK_TYPEREF);
return expr_typeref(opt, astp);
}
case TK_NEWREF:
case TK_NEWBEREF:
case TK_BEREF:
case TK_FUNREF:
case TK_NEWAPP:
case TK_BEAPP:
case TK_FUNAPP:
{
// Qualify the function.
assert(ast_id(type) == TK_FUNTYPE);
ast_t* typeparams = ast_childidx(type, 1);
if(!check_constraints(left, typeparams, right, true))
return false;
type = reify(left, type, typeparams, right);
typeparams = ast_childidx(type, 1);
ast_replace(&typeparams, ast_from(typeparams, TK_NONE));
ast_settype(ast, type);
ast_setid(ast, ast_id(left));
ast_inheritflags(ast);
return true;
}
default: {}
}
assert(0);
return false;
}
// Determine the UIF types that the given formal parameter may be
static int uifset_formal_param(pass_opt_t* opt, ast_t* type_param_ref,
lit_chain_t* chain)
{
assert(type_param_ref != NULL);
assert(ast_id(type_param_ref) == TK_TYPEPARAMREF);
ast_t* type_param = (ast_t*)ast_data(type_param_ref);
assert(type_param != NULL);
assert(ast_id(type_param) == TK_TYPEPARAM);
assert(chain != NULL);
ast_t* constraint = ast_childidx(type_param, 1);
assert(constraint != NULL);
// If the constraint is not a subtype of (Real[A] & Number) then there are no
// legal types in the set
ast_t* number = type_builtin(opt, type_param, "Number");
ast_t* real = type_builtin(opt, type_param, "Real");
ast_setid(ast_childidx(real, 3), TK_BOX);
ast_t* p_ref = ast_childidx(real, 2);
REPLACE(&p_ref,
NODE(TK_TYPEARGS,
NODE(TK_TYPEPARAMREF, DATA(type_param)
ID(ast_name(ast_child(type_param))) NODE(TK_VAL) NONE)));
bool is_real = is_subtype(constraint, real);
bool is_number = is_subtype(constraint, number);
ast_free(number);
ast_free(real);
if(!is_real || !is_number)
// The formal param is not a subset of (Real[A] & Number)
return UIF_NO_TYPES;
int uif_set = 0;
for(int i = 0; i < UIF_COUNT; i++)
{
ast_t* uif = type_builtin(opt, type_param, _str_uif_types[i].name);
BUILD(params, type_param, NODE(TK_TYPEPARAMS, TREE(ast_dup(type_param))));
BUILD(args, type_param, NODE(TK_TYPEARGS, TREE(uif)));
if(check_constraints(params, args, false))
uif_set |= (1 << i);
ast_free(args);
ast_free(params);
}
if(uif_set == 0) // No legal types
return UIF_NO_TYPES;
// Given formal parameter is legal to coerce to
if(chain->formal != NULL && chain->formal != type_param)
{
ast_error(type_param_ref,
"Cannot infer a literal type with multiple formal parameters");
return UIF_ERROR;
}
chain->formal = type_param;
chain->name = ast_name(ast_child(type_param));
return uif_set | UIF_CONSTRAINED;
}
static int
delete_values( Operation *op, Entry *e, Modification *mod, int *newlevel )
{
int i, j, k, found, rc, nl = 0;
Attribute *a;
MatchingRule *mr = mod->sm_desc->ad_type->sat_equality;
/* delete the entire attribute */
if ( mod->sm_values == NULL ) {
int rc = attr_delete( &e->e_attrs, mod->sm_desc );
if ( rc ) {
rc = LDAP_NO_SUCH_ATTRIBUTE;
} else {
*newlevel = 0;
rc = LDAP_SUCCESS;
}
return rc;
}
rc = check_constraints( mod, &nl );
if ( rc != LDAP_SUCCESS ) {
return rc;
}
*newlevel &= ~nl;
if ( mr == NULL || !mr->smr_match ) {
/* disallow specific attributes from being deleted if
* no equality rule */
return LDAP_INAPPROPRIATE_MATCHING;
}
/* delete specific values - find the attribute first */
if ( (a = attr_find( e->e_attrs, mod->sm_desc )) == NULL ) {
return( LDAP_NO_SUCH_ATTRIBUTE );
}
/* find each value to delete */
for ( i = 0; !BER_BVISNULL( &mod->sm_values[ i ] ); i++ ) {
int rc;
const char *text = NULL;
struct berval asserted;
rc = asserted_value_validate_normalize(
mod->sm_desc, mr, SLAP_MR_EQUALITY,
&mod->sm_values[ i ], &asserted, &text,
op->o_tmpmemctx );
if( rc != LDAP_SUCCESS ) return rc;
found = 0;
for ( j = 0; !BER_BVISNULL( &a->a_vals[ j ] ); j++ ) {
int match;
int rc = value_match( &match, mod->sm_desc, mr,
0, &a->a_nvals[ j ], &asserted, &text );
if( rc == LDAP_SUCCESS && match != 0 ) {
continue;
}
/* found a matching value */
found = 1;
/* delete it */
if ( a->a_nvals != a->a_vals ) {
free( a->a_nvals[ j ].bv_val );
for ( k = j + 1; !BER_BVISNULL( &a->a_nvals[ k ] ); k++ ) {
a->a_nvals[ k - 1 ] = a->a_nvals[ k ];
}
BER_BVZERO( &a->a_nvals[ k - 1 ] );
}
free( a->a_vals[ j ].bv_val );
for ( k = j + 1; !BER_BVISNULL( &a->a_vals[ k ] ); k++ ) {
a->a_vals[ k - 1 ] = a->a_vals[ k ];
}
BER_BVZERO( &a->a_vals[ k - 1 ] );
a->a_numvals--;
break;
}
free( asserted.bv_val );
/* looked through them all w/o finding it */
if ( ! found ) {
return LDAP_NO_SUCH_ATTRIBUTE;
}
}
/* if no values remain, delete the entire attribute */
if ( BER_BVISNULL( &a->a_vals[ 0 ] ) ) {
assert( a->a_numvals == 0 );
/* should already be zero */
*newlevel = 0;
if ( attr_delete( &e->e_attrs, mod->sm_desc ) ) {
return LDAP_NO_SUCH_ATTRIBUTE;
}
}
return LDAP_SUCCESS;
}
static int
add_values( Operation *op, Entry *e, Modification *mod, int *newlevel )
{
Attribute *a;
int i, rc;
MatchingRule *mr = mod->sm_desc->ad_type->sat_equality;
assert( mod->sm_values != NULL );
rc = check_constraints( mod, newlevel );
if ( rc != LDAP_SUCCESS ) {
return rc;
}
a = attr_find( e->e_attrs, mod->sm_desc );
if ( a != NULL ) {
/* "managedInfo" SHOULD have appropriate rules ... */
if ( mr == NULL || !mr->smr_match ) {
return LDAP_INAPPROPRIATE_MATCHING;
}
for ( i = 0; !BER_BVISNULL( &mod->sm_values[ i ] ); i++ ) {
int rc;
int j;
const char *text = NULL;
struct berval asserted;
rc = asserted_value_validate_normalize(
mod->sm_desc, mr, SLAP_MR_EQUALITY,
&mod->sm_values[ i ], &asserted, &text,
op->o_tmpmemctx );
if ( rc != LDAP_SUCCESS ) {
return rc;
}
for ( j = 0; !BER_BVISNULL( &a->a_vals[ j ] ); j++ ) {
int match;
int rc = value_match( &match, mod->sm_desc, mr,
0, &a->a_nvals[ j ], &asserted, &text );
if ( rc == LDAP_SUCCESS && match == 0 ) {
free( asserted.bv_val );
return LDAP_TYPE_OR_VALUE_EXISTS;
}
}
free( asserted.bv_val );
}
}
/* no - add them */
rc = attr_merge_normalize( e, mod->sm_desc, mod->sm_values,
op->o_tmpmemctx );
if ( rc != LDAP_SUCCESS ) {
return rc;
}
return LDAP_SUCCESS;
}
/**
* nx842_pseries_compress - Compress data using the 842 algorithm
*
* Compression provide by the NX842 coprocessor on IBM Power systems.
* The input buffer is compressed and the result is stored in the
* provided output buffer.
*
* Upon return from this function @outlen contains the length of the
* compressed data. If there is an error then @outlen will be 0 and an
* error will be specified by the return code from this function.
*
* @in: Pointer to input buffer
* @inlen: Length of input buffer
* @out: Pointer to output buffer
* @outlen: Length of output buffer
* @wrkmem: ptr to buffer for working memory, size determined by
* nx842_pseries_driver.workmem_size
*
* Returns:
* 0 Success, output of length @outlen stored in the buffer at @out
* -ENOMEM Unable to allocate internal buffers
* -ENOSPC Output buffer is to small
* -EIO Internal error
* -ENODEV Hardware unavailable
*/
static int nx842_pseries_compress(const unsigned char *in, unsigned int inlen,
unsigned char *out, unsigned int *outlen,
void *wmem)
{
struct nx842_devdata *local_devdata;
struct device *dev = NULL;
struct nx842_workmem *workmem;
struct nx842_scatterlist slin, slout;
struct nx_csbcpb *csbcpb;
int ret = 0, max_sync_size;
unsigned long inbuf, outbuf;
struct vio_pfo_op op = {
.done = NULL,
.handle = 0,
.timeout = 0,
};
unsigned long start = get_tb();
inbuf = (unsigned long)in;
if (check_constraints(inbuf, &inlen, true))
return -EINVAL;
outbuf = (unsigned long)out;
if (check_constraints(outbuf, outlen, false))
return -EINVAL;
rcu_read_lock();
local_devdata = rcu_dereference(devdata);
if (!local_devdata || !local_devdata->dev) {
rcu_read_unlock();
return -ENODEV;
}
max_sync_size = local_devdata->max_sync_size;
dev = local_devdata->dev;
/* Init scatterlist */
workmem = PTR_ALIGN(wmem, WORKMEM_ALIGN);
slin.entries = (struct nx842_slentry *)workmem->slin;
slout.entries = (struct nx842_slentry *)workmem->slout;
/* Init operation */
op.flags = NX842_OP_COMPRESS;
csbcpb = &workmem->csbcpb;
memset(csbcpb, 0, sizeof(*csbcpb));
op.csbcpb = nx842_get_pa(csbcpb);
if ((inbuf & NX842_HW_PAGE_MASK) ==
((inbuf + inlen - 1) & NX842_HW_PAGE_MASK)) {
/* Create direct DDE */
op.in = nx842_get_pa((void *)inbuf);
op.inlen = inlen;
} else {
/* Create indirect DDE (scatterlist) */
nx842_build_scatterlist(inbuf, inlen, &slin);
op.in = nx842_get_pa(slin.entries);
op.inlen = -nx842_get_scatterlist_size(&slin);
}
if ((outbuf & NX842_HW_PAGE_MASK) ==
((outbuf + *outlen - 1) & NX842_HW_PAGE_MASK)) {
/* Create direct DDE */
op.out = nx842_get_pa((void *)outbuf);
op.outlen = *outlen;
} else {
/* Create indirect DDE (scatterlist) */
nx842_build_scatterlist(outbuf, *outlen, &slout);
op.out = nx842_get_pa(slout.entries);
op.outlen = -nx842_get_scatterlist_size(&slout);
}
dev_dbg(dev, "%s: op.in %lx op.inlen %ld op.out %lx op.outlen %ld\n",
__func__, (unsigned long)op.in, (long)op.inlen,
(unsigned long)op.out, (long)op.outlen);
/* Send request to pHyp */
ret = vio_h_cop_sync(local_devdata->vdev, &op);
/* Check for pHyp error */
if (ret) {
dev_dbg(dev, "%s: vio_h_cop_sync error (ret=%d, hret=%ld)\n",
__func__, ret, op.hcall_err);
ret = -EIO;
goto unlock;
}
/* Check for hardware error */
ret = nx842_validate_result(dev, &csbcpb->csb);
if (ret)
goto unlock;
*outlen = be32_to_cpu(csbcpb->csb.processed_byte_count);
dev_dbg(dev, "%s: processed_bytes=%d\n", __func__, *outlen);
unlock:
if (ret)
nx842_inc_comp_failed(local_devdata);
else {
nx842_inc_comp_complete(local_devdata);
ibm_nx842_incr_hist(local_devdata->counters->comp_times,
(get_tb() - start) / tb_ticks_per_usec);
}
rcu_read_unlock();
return ret;
}
/**
* nx842_pseries_decompress - Decompress data using the 842 algorithm
*
* Decompression provide by the NX842 coprocessor on IBM Power systems.
* The input buffer is decompressed and the result is stored in the
* provided output buffer. The size allocated to the output buffer is
* provided by the caller of this function in @outlen. Upon return from
* this function @outlen contains the length of the decompressed data.
* If there is an error then @outlen will be 0 and an error will be
* specified by the return code from this function.
*
* @in: Pointer to input buffer
* @inlen: Length of input buffer
* @out: Pointer to output buffer
* @outlen: Length of output buffer
* @wrkmem: ptr to buffer for working memory, size determined by
* nx842_pseries_driver.workmem_size
*
* Returns:
* 0 Success, output of length @outlen stored in the buffer at @out
* -ENODEV Hardware decompression device is unavailable
* -ENOMEM Unable to allocate internal buffers
* -ENOSPC Output buffer is to small
* -EINVAL Bad input data encountered when attempting decompress
* -EIO Internal error
*/
static int nx842_pseries_decompress(const unsigned char *in, unsigned int inlen,
unsigned char *out, unsigned int *outlen,
void *wmem)
{
struct nx842_devdata *local_devdata;
struct device *dev = NULL;
struct nx842_workmem *workmem;
struct nx842_scatterlist slin, slout;
struct nx_csbcpb *csbcpb;
int ret = 0, max_sync_size;
unsigned long inbuf, outbuf;
struct vio_pfo_op op = {
.done = NULL,
.handle = 0,
.timeout = 0,
};
unsigned long start = get_tb();
/* Ensure page alignment and size */
inbuf = (unsigned long)in;
if (check_constraints(inbuf, &inlen, true))
return -EINVAL;
outbuf = (unsigned long)out;
if (check_constraints(outbuf, outlen, false))
return -EINVAL;
rcu_read_lock();
local_devdata = rcu_dereference(devdata);
if (!local_devdata || !local_devdata->dev) {
rcu_read_unlock();
return -ENODEV;
}
max_sync_size = local_devdata->max_sync_size;
dev = local_devdata->dev;
workmem = PTR_ALIGN(wmem, WORKMEM_ALIGN);
/* Init scatterlist */
slin.entries = (struct nx842_slentry *)workmem->slin;
slout.entries = (struct nx842_slentry *)workmem->slout;
/* Init operation */
op.flags = NX842_OP_DECOMPRESS;
csbcpb = &workmem->csbcpb;
memset(csbcpb, 0, sizeof(*csbcpb));
op.csbcpb = nx842_get_pa(csbcpb);
if ((inbuf & NX842_HW_PAGE_MASK) ==
((inbuf + inlen - 1) & NX842_HW_PAGE_MASK)) {
/* Create direct DDE */
op.in = nx842_get_pa((void *)inbuf);
op.inlen = inlen;
} else {
/* Create indirect DDE (scatterlist) */
nx842_build_scatterlist(inbuf, inlen, &slin);
op.in = nx842_get_pa(slin.entries);
op.inlen = -nx842_get_scatterlist_size(&slin);
}
if ((outbuf & NX842_HW_PAGE_MASK) ==
((outbuf + *outlen - 1) & NX842_HW_PAGE_MASK)) {
/* Create direct DDE */
op.out = nx842_get_pa((void *)outbuf);
op.outlen = *outlen;
} else {
/* Create indirect DDE (scatterlist) */
nx842_build_scatterlist(outbuf, *outlen, &slout);
op.out = nx842_get_pa(slout.entries);
op.outlen = -nx842_get_scatterlist_size(&slout);
}
dev_dbg(dev, "%s: op.in %lx op.inlen %ld op.out %lx op.outlen %ld\n",
__func__, (unsigned long)op.in, (long)op.inlen,
(unsigned long)op.out, (long)op.outlen);
/* Send request to pHyp */
ret = vio_h_cop_sync(local_devdata->vdev, &op);
/* Check for pHyp error */
if (ret) {
dev_dbg(dev, "%s: vio_h_cop_sync error (ret=%d, hret=%ld)\n",
__func__, ret, op.hcall_err);
goto unlock;
}
/* Check for hardware error */
ret = nx842_validate_result(dev, &csbcpb->csb);
if (ret)
goto unlock;
*outlen = be32_to_cpu(csbcpb->csb.processed_byte_count);
unlock:
if (ret)
/* decompress fail */
nx842_inc_decomp_failed(local_devdata);
else {
nx842_inc_decomp_complete(local_devdata);
ibm_nx842_incr_hist(local_devdata->counters->decomp_times,
(get_tb() - start) / tb_ticks_per_usec);
}
rcu_read_unlock();
return ret;
}
/**
* nx842_OF_set_defaults -- Set default (disabled) values for devdata
*
* @devdata - struct nx842_devdata to update
*
* Returns:
* 0 on success
* -ENOENT if @devdata ptr is NULL
*/
static int nx842_OF_set_defaults(struct nx842_devdata *devdata)
{
if (devdata) {
devdata->max_sync_size = 0;
devdata->max_sync_sg = 0;
devdata->max_sg_len = 0;
return 0;
} else
return -ENOENT;
}
/**
* nx842_OF_upd_status -- Check the device info from OF status prop
*
* The status property indicates if the accelerator is enabled. If the
* device is in the OF tree it indicates that the hardware is present.
* The status field indicates if the device is enabled when the status
* is 'okay'. Otherwise the device driver will be disabled.
*
* @prop - struct property point containing the maxsyncop for the update
*
* Returns:
* 0 - Device is available
* -ENODEV - Device is not available
*/
static int nx842_OF_upd_status(struct property *prop)
{
const char *status = (const char *)prop->value;
if (!strncmp(status, "okay", (size_t)prop->length))
return 0;
if (!strncmp(status, "disabled", (size_t)prop->length))
return -ENODEV;
dev_info(devdata->dev, "%s: unknown status '%s'\n", __func__, status);
return -EINVAL;
}
/**
* nx842_OF_upd_maxsglen -- Update the device info from OF maxsglen prop
*
* Definition of the 'ibm,max-sg-len' OF property:
* This field indicates the maximum byte length of a scatter list
* for the platform facility. It is a single cell encoded as with encode-int.
*
* Example:
* # od -x ibm,max-sg-len
* 0000000 0000 0ff0
*
* In this example, the maximum byte length of a scatter list is
* 0x0ff0 (4,080).
*
* @devdata - struct nx842_devdata to update
* @prop - struct property point containing the maxsyncop for the update
*
* Returns:
* 0 on success
* -EINVAL on failure
*/
static int nx842_OF_upd_maxsglen(struct nx842_devdata *devdata,
struct property *prop) {
int ret = 0;
const unsigned int maxsglen = of_read_number(prop->value, 1);
if (prop->length != sizeof(maxsglen)) {
dev_err(devdata->dev, "%s: unexpected format for ibm,max-sg-len property\n", __func__);
dev_dbg(devdata->dev, "%s: ibm,max-sg-len is %d bytes long, expected %lu bytes\n", __func__,
prop->length, sizeof(maxsglen));
ret = -EINVAL;
} else {
devdata->max_sg_len = min_t(unsigned int,
maxsglen, NX842_HW_PAGE_SIZE);
}
return ret;
}
/**
* nx842_OF_upd_maxsyncop -- Update the device info from OF maxsyncop prop
*
* Definition of the 'ibm,max-sync-cop' OF property:
* Two series of cells. The first series of cells represents the maximums
* that can be synchronously compressed. The second series of cells
* represents the maximums that can be synchronously decompressed.
* 1. The first cell in each series contains the count of the number of
* data length, scatter list elements pairs that follow – each being
* of the form
* a. One cell data byte length
* b. One cell total number of scatter list elements
*
* Example:
* # od -x ibm,max-sync-cop
* 0000000 0000 0001 0000 1000 0000 01fe 0000 0001
* 0000020 0000 1000 0000 01fe
*
* In this example, compression supports 0x1000 (4,096) data byte length
* and 0x1fe (510) total scatter list elements. Decompression supports
* 0x1000 (4,096) data byte length and 0x1f3 (510) total scatter list
* elements.
*
* @devdata - struct nx842_devdata to update
* @prop - struct property point containing the maxsyncop for the update
*
* Returns:
* 0 on success
* -EINVAL on failure
*/
static int nx842_OF_upd_maxsyncop(struct nx842_devdata *devdata,
struct property *prop) {
int ret = 0;
unsigned int comp_data_limit, decomp_data_limit;
unsigned int comp_sg_limit, decomp_sg_limit;
const struct maxsynccop_t {
__be32 comp_elements;
__be32 comp_data_limit;
__be32 comp_sg_limit;
__be32 decomp_elements;
__be32 decomp_data_limit;
__be32 decomp_sg_limit;
} *maxsynccop;
if (prop->length != sizeof(*maxsynccop)) {
dev_err(devdata->dev, "%s: unexpected format for ibm,max-sync-cop property\n", __func__);
dev_dbg(devdata->dev, "%s: ibm,max-sync-cop is %d bytes long, expected %lu bytes\n", __func__, prop->length,
sizeof(*maxsynccop));
ret = -EINVAL;
goto out;
}
maxsynccop = (const struct maxsynccop_t *)prop->value;
comp_data_limit = be32_to_cpu(maxsynccop->comp_data_limit);
comp_sg_limit = be32_to_cpu(maxsynccop->comp_sg_limit);
decomp_data_limit = be32_to_cpu(maxsynccop->decomp_data_limit);
decomp_sg_limit = be32_to_cpu(maxsynccop->decomp_sg_limit);
/* Use one limit rather than separate limits for compression and
* decompression. Set a maximum for this so as not to exceed the
* size that the header can support and round the value down to
* the hardware page size (4K) */
devdata->max_sync_size = min(comp_data_limit, decomp_data_limit);
devdata->max_sync_size = min_t(unsigned int, devdata->max_sync_size,
65536);
if (devdata->max_sync_size < 4096) {
dev_err(devdata->dev, "%s: hardware max data size (%u) is "
"less than the driver minimum, unable to use "
"the hardware device\n",
__func__, devdata->max_sync_size);
ret = -EINVAL;
goto out;
}
nx842_pseries_constraints.maximum = devdata->max_sync_size;
devdata->max_sync_sg = min(comp_sg_limit, decomp_sg_limit);
if (devdata->max_sync_sg < 1) {
dev_err(devdata->dev, "%s: hardware max sg size (%u) is "
"less than the driver minimum, unable to use "
"the hardware device\n",
__func__, devdata->max_sync_sg);
ret = -EINVAL;
goto out;
}
out:
return ret;
}
bool expr_qualify(pass_opt_t* opt, ast_t** astp)
{
// Left is a postfix expression, right is a typeargs.
ast_t* ast = *astp;
AST_GET_CHILDREN(ast, left, right);
ast_t* type = ast_type(left);
assert(ast_id(right) == TK_TYPEARGS);
if(is_typecheck_error(type))
return false;
switch(ast_id(left))
{
case TK_TYPEREF:
{
// Qualify the type.
assert(ast_id(type) == TK_NOMINAL);
// If the type isn't polymorphic or the type is already qualified,
// sugar .apply().
ast_t* def = names_def(opt, type);
ast_t* typeparams = ast_childidx(def, 1);
if((ast_id(typeparams) == TK_NONE) ||
(ast_id(ast_childidx(type, 2)) != TK_NONE))
{
if(!expr_nominal(opt, &type))
return false;
break;
}
type = ast_dup(type);
ast_t* typeargs = ast_childidx(type, 2);
ast_replace(&typeargs, right);
ast_settype(ast, type);
ast_setid(ast, TK_TYPEREF);
return expr_typeref(opt, astp);
}
case TK_NEWREF:
case TK_NEWBEREF:
case TK_BEREF:
case TK_FUNREF:
case TK_NEWAPP:
case TK_BEAPP:
case TK_FUNAPP:
{
// Qualify the function.
assert(ast_id(type) == TK_FUNTYPE);
ast_t* typeparams = ast_childidx(type, 1);
if(!reify_defaults(typeparams, right, true, opt))
return false;
if(!check_constraints(left, typeparams, right, true, opt))
return false;
type = reify(type, typeparams, right, opt);
typeparams = ast_childidx(type, 1);
ast_replace(&typeparams, ast_from(typeparams, TK_NONE));
ast_settype(ast, type);
ast_setid(ast, ast_id(left));
ast_inheritflags(ast);
return true;
}
default: {}
}
// Sugar .apply()
ast_t* dot = ast_from(left, TK_DOT);
ast_add(dot, ast_from_string(left, "apply"));
ast_swap(left, dot);
ast_add(dot, left);
if(!expr_dot(opt, &dot))
return false;
return expr_qualify(opt, astp);
}
void cctest (cholmod_sparse *A)
{
double knobs [CCOLAMD_KNOBS], knobs2 [CCOLAMD_KNOBS] ;
Int *P, *Cmember, *Cp, *Ci, *Front_npivcol, *Front_nrows, *Front_ncols,
*Front_parent, *Front_cols, *InFront, *Si, *Sp ;
cholmod_sparse *C, *A2, *B, *S ;
Int nrow, ncol, alen, ok, stats [CCOLAMD_STATS], csets, i, nfr, c, p ;
size_t s ;
/* ---------------------------------------------------------------------- */
/* get inputs */
/* ---------------------------------------------------------------------- */
my_srand (42) ; /* RAND reset */
printf ("\nCCOLAMD test\n") ;
if (A == NULL)
{
return ;
}
if (A->stype)
{
A2 = CHOLMOD(copy) (A, 0, 0, cm) ;
B = A2 ;
}
else
{
A2 = NULL ;
B = A ;
}
S = CHOLMOD(copy_sparse) (A, cm) ;
nrow = B->nrow ;
ncol = B->ncol ;
Si = S->i ;
Sp = S->p ;
/* ---------------------------------------------------------------------- */
/* allocate workspace and Cmember for ccolamd */
/* ---------------------------------------------------------------------- */
P = CHOLMOD(malloc) (nrow+1, sizeof (Int), cm) ;
Cmember = CHOLMOD(malloc) (nrow, sizeof (Int), cm) ;
Front_npivcol = CHOLMOD(malloc) (nrow+1, sizeof (Int), cm) ;
Front_nrows = CHOLMOD(malloc) (nrow+1, sizeof (Int), cm) ;
Front_ncols = CHOLMOD(malloc) (nrow+1, sizeof (Int), cm) ;
Front_parent = CHOLMOD(malloc) (nrow+1, sizeof (Int), cm) ;
Front_cols = CHOLMOD(malloc) (nrow+1, sizeof (Int), cm) ;
InFront = CHOLMOD(malloc) (ncol, sizeof (Int), cm) ;
csets = MIN (6, nrow) ;
for (i = 0 ; i < nrow ; i++)
{
Cmember [i] = nrand (csets) ;
}
CCOLAMD_set_defaults (knobs) ;
CCOLAMD_set_defaults (knobs2) ;
CCOLAMD_set_defaults (NULL) ;
CCOLAMD_report (NULL) ;
CSYMAMD_report (NULL) ;
alen = CCOLAMD_recommended (B->nzmax, ncol, nrow) ;
C = CHOLMOD(allocate_sparse) (ncol, nrow, alen, TRUE, TRUE, 0,
CHOLMOD_PATTERN, cm) ;
Cp = C->p ;
Ci = C->i ;
/* ---------------------------------------------------------------------- */
/* order with ccolamd */
/* ---------------------------------------------------------------------- */
ok = CHOLMOD(transpose_unsym) (B, 0, NULL, NULL, 0, C, cm) ; OK (ok) ;
CHOLMOD(print_sparse) (C, "C for ccolamd", cm) ;
ok = CCOLAMD_MAIN (ncol, nrow, alen, Ci, Cp, NULL, stats, Cmember) ;
CCOLAMD_report (stats) ;
OK (ok) ;
ok = stats [CCOLAMD_STATUS] ;
ok = (ok == CCOLAMD_OK || ok == CCOLAMD_OK_BUT_JUMBLED) ;
OK (ok) ;
/* permutation returned in C->p, if the ordering succeeded */
/* make sure P obeys the constraints */
OK (check_constraints (Cp, Cmember, nrow)) ;
/* ---------------------------------------------------------------------- */
/* order with ccolamd2 */
/* ---------------------------------------------------------------------- */
ok = CHOLMOD(transpose_unsym) (B, 0, NULL, NULL, 0, C, cm) ; OK (ok) ;
ok = CCOLAMD_2 (ncol, nrow, alen, Ci, Cp, NULL, stats,
Front_npivcol, Front_nrows, Front_ncols, Front_parent,
Front_cols, &nfr, InFront, Cmember) ;
CCOLAMD_report (stats) ;
OK (check_constraints (Cp, Cmember, nrow)) ;
/* ---------------------------------------------------------------------- */
/* with a small dense-row threshold */
/* ---------------------------------------------------------------------- */
knobs2 [CCOLAMD_DENSE_ROW] = 0 ;
ok = CHOLMOD(transpose_unsym) (B, 0, NULL, NULL, 0, C, cm) ; OK (ok) ;
ok = CCOLAMD_MAIN (ncol, nrow, alen, Ci, Cp, knobs2, stats, Cmember) ;
CCOLAMD_report (stats) ;
knobs2 [CCOLAMD_DENSE_ROW] = 0.625 ;
knobs2 [CCOLAMD_DENSE_COL] = 0 ;
ok = CHOLMOD(transpose_unsym) (B, 0, NULL, NULL, 0, C, cm) ; OK (ok) ;
ok = CCOLAMD_MAIN (ncol, nrow, alen, Ci, Cp, knobs2, stats, Cmember) ;
CCOLAMD_report (stats) ;
knobs2 [CCOLAMD_DENSE_ROW] = 0.625 ;
knobs2 [CCOLAMD_DENSE_COL] = -1 ;
ok = CHOLMOD(transpose_unsym) (B, 0, NULL, NULL, 0, C, cm) ; OK (ok) ;
ok = CCOLAMD_MAIN (ncol, nrow, alen, Ci, Cp, knobs2, stats, Cmember) ;
CCOLAMD_report (stats) ;
knobs2 [CCOLAMD_DENSE_COL] = 0 ;
/* ---------------------------------------------------------------------- */
/* duplicate entries */
/* ---------------------------------------------------------------------- */
if (ncol > 2 && nrow > 2)
{
ok = CHOLMOD(transpose_unsym) (B, 0, NULL, NULL, 0, C, cm) ;
OK (ok) ;
if (Cp [1] - Cp [0] > 2)
{
Ci [0] = Ci [1] ;
}
ok = CCOLAMD_MAIN (ncol, nrow, alen, Ci, Cp, knobs2, stats, Cmember) ;
CCOLAMD_report (stats) ;
OK (CHOLMOD(print_perm) (Cp, nrow, nrow, "ccolamd perm", cm)) ;
}
/* ---------------------------------------------------------------------- */
/* csymamd */
/* ---------------------------------------------------------------------- */
if (nrow == ncol)
{
Int n = nrow ;
ok = CSYMAMD_MAIN (n, Si, Sp, P, NULL, stats,
cm->calloc_memory, cm->free_memory, Cmember, A->stype) ;
OK (ok) ;
OK (check_constraints (P, Cmember, n)) ;
CSYMAMD_report (stats) ;
/* ------------------------------------------------------------------ */
/* csymamd errors */
/* ------------------------------------------------------------------ */
ok = CSYMAMD_MAIN (n, Si, Sp, P, NULL, NULL, cm->calloc_memory,
cm->free_memory, Cmember, A->stype) ; NOT (ok);
ok = CSYMAMD_MAIN (n, NULL, Sp, P, NULL, stats, cm->calloc_memory,
cm->free_memory, Cmember, A->stype) ; NOT (ok);
CSYMAMD_report (stats) ;
ok = CSYMAMD_MAIN (n, Si, NULL, P, NULL, stats, cm->calloc_memory,
cm->free_memory, Cmember, A->stype) ; NOT (ok);
CSYMAMD_report (stats) ;
ok = CSYMAMD_MAIN (-1, Si, Sp, P, NULL, stats, cm->calloc_memory,
cm->free_memory, Cmember, A->stype) ; NOT (ok);
CSYMAMD_report (stats) ;
p = Sp [n] ;
Sp [n] = -1 ;
ok = CSYMAMD_MAIN (n, Si, Sp, P, NULL, stats, cm->calloc_memory,
cm->free_memory, Cmember, A->stype) ; NOT (ok);
CSYMAMD_report (stats) ;
Sp [n] = p ;
Sp [0] = -1 ;
ok = CSYMAMD_MAIN (n, Si, Sp, P, NULL, stats, cm->calloc_memory,
cm->free_memory, Cmember, A->stype) ; NOT (ok);
CSYMAMD_report (stats) ;
Sp [0] = 0 ;
if (n > 2 && Sp [n] > 3)
{
p = Sp [1] ;
Sp [1] = -1 ;
ok = CSYMAMD_MAIN (n, Si, Sp, P, NULL, stats, cm->calloc_memory,
cm->free_memory, Cmember, A->stype) ; NOT (ok);
CSYMAMD_report (stats) ;
Sp [1] = p ;
i = Si [0] ;
Si [0] = -1 ;
ok = CSYMAMD_MAIN (n, Si, Sp, P, NULL, stats, cm->calloc_memory,
cm->free_memory, Cmember, A->stype) ; NOT (ok);
CSYMAMD_report (stats) ;
Si [0] = i ;
/* ok, but jumbled */
i = Si [0] ;
Si [0] = Si [1] ;
Si [1] = i ;
ok = CSYMAMD_MAIN (n, Si, Sp, P, NULL, stats, cm->calloc_memory,
cm->free_memory, Cmember, A->stype) ; OK (ok);
CSYMAMD_report (stats) ;
i = Si [0] ;
Si [0] = Si [1] ;
Si [1] = i ;
test_memory_handler ( ) ;
ok = CSYMAMD_MAIN (n, Si, Sp, P, NULL, stats, cm->calloc_memory,
cm->free_memory, Cmember, A->stype) ; NOT(ok);
CSYMAMD_report (stats) ;
normal_memory_handler ( ) ;
}
}
/* ---------------------------------------------------------------------- */
/* error tests */
/* ---------------------------------------------------------------------- */
ok = CHOLMOD(transpose_unsym) (B, 0, NULL, NULL, 0, C, cm) ; OK (ok) ;
ok = CCOLAMD_MAIN (ncol, nrow, 0, Ci, Cp, knobs, stats, Cmember) ; NOT (ok) ;
CCOLAMD_report (stats) ;
ok = CCOLAMD_MAIN (ncol, nrow, alen, NULL, Cp, knobs, stats, Cmember); NOT (ok) ;
CCOLAMD_report (stats) ;
ok = CCOLAMD_MAIN (ncol, nrow, alen, Ci, NULL, knobs, stats, Cmember); NOT (ok) ;
CCOLAMD_report (stats) ;
ok = CCOLAMD_MAIN (ncol, nrow, alen, Ci, Cp, knobs, NULL, Cmember) ; NOT (ok) ;
CCOLAMD_report (stats) ;
ok = CCOLAMD_MAIN (-1, nrow, alen, Ci, Cp, knobs, stats, Cmember) ; NOT (ok) ;
CCOLAMD_report (stats) ;
ok = CCOLAMD_MAIN (ncol, -1, alen, Ci, Cp, knobs, stats, Cmember) ; NOT (ok) ;
CCOLAMD_report (stats) ;
ok = CHOLMOD(transpose_unsym) (B, 0, NULL, NULL, 0, C, cm) ; OK (ok) ;
Cp [nrow] = -1 ;
ok = CCOLAMD_MAIN (ncol, nrow, alen, Ci, Cp, knobs, stats, Cmember) ; NOT (ok) ;
CCOLAMD_report (stats) ;
Cp [0] = 1 ;
ok = CCOLAMD_MAIN (ncol, nrow, alen, Ci, Cp, knobs, stats, Cmember) ; NOT (ok) ;
CCOLAMD_report (stats) ;
ok = CHOLMOD(transpose_unsym) (B, 0, NULL, NULL, 0, C, cm) ; OK (ok) ;
if (nrow > 0 && alen > 0 && Cp [1] > 0)
{
c = Cmember [0] ;
Cmember [0] = -1 ;
ok = CCOLAMD_MAIN (ncol, nrow, alen, Ci, Cp, knobs, stats, Cmember) ;NOT(ok);
CCOLAMD_report (stats) ;
Cmember [0] = c ;
p = Cp [1] ;
Cp [1] = -1 ;
ok = CCOLAMD_MAIN (ncol, nrow, alen, Ci, Cp, knobs, stats, Cmember) ;NOT(ok);
CCOLAMD_report (stats) ;
Cp [1] = p ;
i = Ci [0] ;
Ci [0] = -1 ;
ok = CCOLAMD_MAIN (ncol, nrow, alen, Ci, Cp, knobs, stats, Cmember) ;NOT(ok);
CCOLAMD_report (stats) ;
Ci [0] = i ;
}
s = CCOLAMD_recommended (-1, 0, 0) ;
OK (s == 0) ;
/* ---------------------------------------------------------------------- */
/* free workspace */
/* ---------------------------------------------------------------------- */
CHOLMOD(free) (nrow+1, sizeof (Int), Front_npivcol, cm) ;
CHOLMOD(free) (nrow+1, sizeof (Int), Front_nrows, cm) ;
CHOLMOD(free) (nrow+1, sizeof (Int), Front_ncols, cm) ;
CHOLMOD(free) (nrow+1, sizeof (Int), Front_parent, cm) ;
CHOLMOD(free) (nrow+1, sizeof (Int), Front_cols, cm) ;
CHOLMOD(free) (nrow+1, sizeof (Int), P, cm) ;
CHOLMOD(free) (nrow, sizeof (Int), Cmember, cm) ;
CHOLMOD(free) (ncol, sizeof (Int), InFront, cm) ;
CHOLMOD(free_sparse) (&S, cm) ;
CHOLMOD(free_sparse) (&A2, cm) ;
CHOLMOD(free_sparse) (&C, cm) ;
cm->print = 1 ;
}