void find_all_compatible_bids(int index){
int i;
int size;
nbd_size=0;
int counter=0;
for(i=0;i<num_of_bids;i++)
if(check_compatibility(index,i))
nbd_list_answer[nbd_size++]=i;
if(nbd_size > 30)
_("more than 30 neigbours!!");
printf("%d\n",nbd_size );
}
int check_connectedness(bid_info *current,int *chosen,int size){
int i;
int j;
int value=0;
for(i=0;i<size;i++){
for(j=i+1;j<size;j++){
if(!check_compatibility(current->compatible_bids[chosen[i]], current->compatible_bids[chosen[j]])){
return INT_MIN;
}
}
value+=bid_list[current->compatible_bids[chosen[i]]]->bid_value;
}
return value;
}
void s390_realize_cpu_model(CPUState *cs, Error **errp)
{
S390CPUClass *xcc = S390_CPU_GET_CLASS(cs);
S390CPU *cpu = S390_CPU(cs);
const S390CPUModel *max_model;
if (xcc->kvm_required && !kvm_enabled()) {
error_setg(errp, "CPU definition requires KVM");
return;
}
if (!cpu->model) {
/* no host model support -> perform compatibility stuff */
apply_cpu_model(NULL, errp);
return;
}
max_model = get_max_cpu_model(errp);
if (*errp) {
error_prepend(errp, "CPU models are not available: ");
return;
}
/* copy over properties that can vary */
cpu->model->lowest_ibc = max_model->lowest_ibc;
cpu->model->cpu_id = max_model->cpu_id;
cpu->model->cpu_id_format = max_model->cpu_id_format;
cpu->model->cpu_ver = max_model->cpu_ver;
check_consistency(cpu->model);
check_compatibility(max_model, cpu->model, errp);
if (*errp) {
return;
}
apply_cpu_model(cpu->model, errp);
cpu->env.cpuid = s390_cpuid_from_cpu_model(cpu->model);
if (tcg_enabled()) {
/* basic mode, write the cpu address into the first 4 bit of the ID */
cpu->env.cpuid = deposit64(cpu->env.cpuid, 54, 4, cpu->env.cpu_num);
}
}
void s390_realize_cpu_model(CPUState *cs, Error **errp)
{
S390CPUClass *xcc = S390_CPU_GET_CLASS(cs);
S390CPU *cpu = S390_CPU(cs);
const S390CPUModel *max_model;
if (xcc->kvm_required && !kvm_enabled()) {
error_setg(errp, "CPU definition requires KVM");
return;
}
if (!cpu->model) {
/* no host model support -> perform compatibility stuff */
apply_cpu_model(NULL, errp);
return;
}
max_model = get_max_cpu_model(errp);
if (*errp) {
error_prepend(errp, "CPU models are not available: ");
return;
}
/* copy over properties that can vary */
cpu->model->lowest_ibc = max_model->lowest_ibc;
cpu->model->cpu_id = max_model->cpu_id;
cpu->model->cpu_ver = max_model->cpu_ver;
check_consistency(cpu->model);
check_compatibility(max_model, cpu->model, errp);
if (*errp) {
return;
}
apply_cpu_model(cpu->model, errp);
}
bool upd765_format::save(io_generic *io, floppy_image *image)
{
// Count the number of formats
int formats_count;
for(formats_count=0; formats[formats_count].form_factor; formats_count++);
// Allocate the storage for the list of testable formats for a
// given cell size
int *candidates = global_alloc_array(int, formats_count);
// Format we're finally choosing
int chosen_candidate = -1;
// Previously tested cell size
int min_cell_size = 0;
for(;;) {
// Build the list of all formats for the immediatly superior cell size
int cur_cell_size = 0;
int candidates_count = 0;
for(int i=0; i != formats_count; i++) {
if(image->get_form_factor() == floppy_image::FF_UNKNOWN ||
image->get_form_factor() == formats[i].form_factor) {
if(formats[i].cell_size == cur_cell_size)
candidates[candidates_count++] = i;
else if((!cur_cell_size || formats[i].cell_size < cur_cell_size) &&
formats[i].cell_size > min_cell_size) {
candidates[0] = i;
candidates_count = 1;
cur_cell_size = formats[i].cell_size;
}
}
}
min_cell_size = cur_cell_size;
// No candidates with a cell size bigger than the previously
// tested one, we're done
if(!candidates_count)
break;
// Filter with track 0 head 0
check_compatibility(image, candidates, candidates_count);
// Nobody matches, try with the next cell size
if(!candidates_count)
continue;
// We have a match at that cell size, we just need to find the
// best one given the geometry
// If there's only one, we're done
if(candidates_count == 1) {
chosen_candidate = candidates[0];
break;
}
// Otherwise, find the best
int tracks, heads;
image->get_actual_geometry(tracks, heads);
chosen_candidate = candidates[0];
for(int i=1; i != candidates_count; i++) {
const format &cc = formats[chosen_candidate];
const format &cn = formats[candidates[i]];
// Handling enough sides is better than not
if(cn.head_count >= heads && cc.head_count < heads)
goto change;
else if(cc.head_count >= heads && cn.head_count < heads)
goto dont_change;
// Since we're limited to two heads, at that point head
// count is identical for both formats.
// Handling enough tracks is better than not
if(cn.track_count >= tracks && cc.track_count < tracks)
goto change;
else if(cn.track_count >= tracks && cc.track_count < tracks)
goto dont_change;
// Both are on the same side of the track count, so closest is best
if(cc.track_count < tracks && cn.track_count > cc.track_count)
goto change;
if(cc.track_count >= tracks && cn.track_count < cc.track_count)
goto change;
goto dont_change;
change:
chosen_candidate = candidates[i];
dont_change:
;
}
// We have a winner, bail out
break;
}
// No match, pick the first one and be done with it
if(chosen_candidate == -1)
chosen_candidate = 0;
const format &f = formats[chosen_candidate];
int track_size = compute_track_size(f);
UINT8 sectdata[40*512];
desc_s sectors[40];
build_sector_description(f, sectdata, sectors);
for(int track=0; track < f.track_count; track++)
for(int head=0; head < f.head_count; head++) {
extract_sectors(image, f, sectors, track, head);
io_generic_write(io, sectdata, (track*f.head_count + head)*track_size, track_size);
}
return true;
}
pedge* edge_bundling(SparseMatrix A0, int dim, real *x, int maxit_outer, real K, int method, int nneighbor, int compatibility_method,
int max_recursion, real angle_param, real angle, int open_gl){
/* bundle edges.
A: edge graph
x: edge i is at {p,q},
. where p = x[2*dim*i : 2*dim*i+dim-1]
. and q = x[2*dim*i+dim : 2*dim*i+2*dim-1]
maxit_outer: max outer iteration for force directed bundling. Every outer iter subdivide each edge segment into 2.
K: norminal edge length in force directed bundling
method: which method to use.
nneighbor: number of neighbors to be used in forming nearest neighbor graph. Used only in agglomerative method
compatibility_method: which method to use to calculate compatibility. Used only in force directed.
max_recursion: used only in agglomerative method. Specify how many level of recursion to do to bundle bundled edges again
open_gl: whether to plot in X.
*/
int ne = A0->m;
pedge *edges;
SparseMatrix A = A0, B = NULL;
int i;
real tol = 0.001;
int k;
real step0 = 0.1, start = 0.0;
int maxit = 10;
int flag;
assert(A->n == ne);
edges = MALLOC(sizeof(pedge)*ne);
for (i = 0; i < ne; i++){
edges[i] = pedge_new(2, dim, &(x[dim*2*i]));
}
A = SparseMatrix_symmetrize(A0, TRUE);
if (Verbose) start = clock();
if (method == METHOD_INK){
/* go through the links and make sure edges are compatible */
B = check_compatibility(A, ne, edges, compatibility_method, tol);
edges = modularity_ink_bundling(dim, ne, B, edges, angle_param, angle);
} else if (method == METHOD_INK_AGGLOMERATE){
#ifdef HAVE_ANN
/* plan: merge a node with its neighbors if doing so improve. Form coarsening graph, repeat until no more ink saving */
edges = agglomerative_ink_bundling(dim, A, edges, nneighbor, max_recursion, angle_param, angle, open_gl, &flag);
assert(!flag);
#else
agerr (AGERR, "Graphviz built without approximate nearest neighbor library ANN; agglomerative inking not available\n");
edges = edges;
#endif
} else if (method == METHOD_FD){/* FD method */
/* go through the links and make sure edges are compatible */
B = check_compatibility(A, ne, edges, compatibility_method, tol);
for (k = 0; k < maxit_outer; k++){
for (i = 0; i < ne; i++){
edges[i] = pedge_double(edges[i]);
}
step0 = step0/2;
edges = force_directed_edge_bundling(B, edges, maxit, step0, K, open_gl);
}
} else if (method == METHOD_NONE){
edges = edges;
} else {
assert(0);
}
if (Verbose)
fprintf(stderr, "total edge bundling cpu = %f\n",((real) (clock() - start))/CLOCKS_PER_SEC);
if (B != A) SparseMatrix_delete(B);
if (A != A0) SparseMatrix_delete(A);
return edges;
}
int main(int argc, char **argv)
{
int ret, i;
struct XorrisO *xorriso= NULL;
char **orig_argv= NULL;
check_compatibility(); /* might exit() */
if(argc < 2) {
yell_xorriso();
fprintf(stderr,"usage : %s [options]\n", argv[0]);
fprintf(stderr, " More is told by option -help\n");
exit(2);
}
setlocale(LC_CTYPE, "");
ret= Xorriso_new(&xorriso, argv[0], 0);
if(ret <= 0) {
fprintf(stderr,"Creation of XorrisO object failed. (not enough memory ?)\n");
exit(3);
}
/* The prescan of arguments performs actions which have to happen before
the normal processing of startup files and arguments.
Among them are -help and -prog_help which end the program without
yelling its name and version.
*/
ret= Xorriso_prescan_args(xorriso,argc,argv,0);
if(ret == 0)
goto end_successfully;
/* Put out program name and version to stderr only if not done already now */
yell_xorriso();
if(ret < 0)
exit(5);
/* After having yelled xorriso, prescan again for unknown arguments */
ret= Xorriso_prescan_args(xorriso, argc, argv, 2);
if(ret < 0)
exit(5);
/* The following command interpreters are allowed only after this
initialization.
*/
ret= Xorriso_startup_libraries(xorriso, 0);
if(ret <= 0)
{ret= 4; goto emergency_exit;}
Xorriso_process_msg_queues(xorriso, 0);
/* Interpret startup files */
ret= Xorriso_read_rc(xorriso, 0);
if(ret == 3)
goto end_successfully;
if(ret <= 0)
{ret= 5; goto emergency_exit;}
/* Interpret program arguments */
orig_argv= argv;
ret= Xorriso_program_arg_bsl(xorriso, argc, &argv, 0);
if(ret <= 0)
{ret= 5; goto emergency_exit;}
i= 1;
ret= Xorriso_interpreter(xorriso, argc, argv, &i, 2);
if(ret == 3)
goto end_successfully;
if(ret <= 0)
{ret= 5; goto emergency_exit;}
/* Enter dialog mode if it has been activated meanwhile */
ret= Xorriso_dialog(xorriso, 0);
if(ret <= 0)
{ret= 6; goto emergency_exit;}
end_successfully:; /* normal shutdown, including eventual -commit */
Xorriso_stop_msg_watcher(xorriso, 1);
Xorriso_process_msg_queues(xorriso, 0);
if(Xorriso_change_is_pending(xorriso, 1))
Xorriso_option_end(xorriso, 2);
Xorriso_process_msg_queues(xorriso, 0);
ret= Xorriso_make_return_value(xorriso, 0);
Xorriso_process_errfile(xorriso, 0, "xorriso end", 0, 1);
Xorriso_destroy(&xorriso, 1);
if(orig_argv != argv && orig_argv != NULL) {
for(i= 0; i < argc; i++)
if(argv[i] != NULL)
free(argv[i]);
free(argv);
}
exit(ret);
emergency_exit:;
if(xorriso != NULL) { /* minimal shutdown */
Xorriso_process_msg_queues(xorriso, 0);
Xorriso_destroy(&xorriso, 1);
}
exit(ret);
}
bool wd177x_format::save(io_generic *io, floppy_image *image)
{
// Count the number of formats
int formats_count;
for(formats_count=0; formats[formats_count].form_factor; formats_count++) {};
// Allocate the storage for the list of testable formats for a
// given cell size
std::vector<int> candidates;
// Format we're finally choosing
int chosen_candidate = -1;
// Previously tested cell size
int min_cell_size = 0;
for(;;) {
// Build the list of all formats for the immediately superior cell size
int cur_cell_size = 0;
candidates.clear();
for(int i=0; i != formats_count; i++) {
if(image->get_form_factor() == floppy_image::FF_UNKNOWN ||
image->get_form_factor() == formats[i].form_factor) {
if(formats[i].cell_size == cur_cell_size)
candidates.push_back(i);
else if((!cur_cell_size || formats[i].cell_size < cur_cell_size) &&
formats[i].cell_size > min_cell_size) {
candidates.clear();
candidates.push_back(i);
cur_cell_size = formats[i].cell_size;
}
}
}
min_cell_size = cur_cell_size;
// No candidates with a cell size bigger than the previously
// tested one, we're done
if(candidates.empty())
break;
// Filter with track 0 head 0
check_compatibility(image, candidates);
// Nobody matches, try with the next cell size
if(candidates.empty())
continue;
// We have a match at that cell size, we just need to find the
// best one given the geometry
// If there's only one, we're done
if(candidates.size() == 1) {
chosen_candidate = candidates[0];
break;
}
// Otherwise, find the best
int tracks, heads;
image->get_actual_geometry(tracks, heads);
chosen_candidate = candidates[0];
for(unsigned int i=1; i != candidates.size(); i++) {
const format &cc = formats[chosen_candidate];
const format &cn = formats[candidates[i]];
// Handling enough sides is better than not
if(cn.head_count >= heads && cc.head_count < heads)
goto change;
else if(cc.head_count >= heads && cn.head_count < heads)
goto dont_change;
// Handling enough tracks is better than not
if(cn.track_count >= tracks && cc.track_count < tracks)
goto change;
else if(cc.track_count >= tracks && cn.track_count < tracks)
goto dont_change;
// Both are on the same side of the track count, so closest is best
if(cc.track_count < tracks && cn.track_count > cc.track_count)
goto change;
if(cc.track_count >= tracks && cn.track_count < cc.track_count)
goto change;
// Lower number of heads is better
if (cn.head_count < cc.head_count && cn.head_count <= heads)
goto change;
goto dont_change;
change:
chosen_candidate = candidates[i];
dont_change:
;
}
// We have a winner, bail out
break;
}
// No match, pick the first one and be done with it
if(chosen_candidate == -1)
chosen_candidate = 0;
const format &f = formats[chosen_candidate];
int track_size = compute_track_size(f);
uint8_t sectdata[40*512];
desc_s sectors[40];
for(int track=0; track < f.track_count; track++)
for(int head=0; head < f.head_count; head++) {
build_sector_description(f, sectdata, sectors, track, head);
extract_sectors(image, f, sectors, track, head);
io_generic_write(io, sectdata, get_image_offset(f, head, track), track_size);
}
return true;
}