nc_color vehicle::part_color( const int p, const bool exact ) const
{
if( p < 0 || p >= ( int )parts.size() ) {
return c_black;
}
nc_color col;
int parm = -1;
//If armoring is present and the option is set, it colors the visible part
if( get_option<bool>( "VEHICLE_ARMOR_COLOR" ) ) {
parm = part_with_feature( p, VPFLAG_ARMOR, false );
}
if( parm >= 0 ) {
col = part_info( parm ).color;
} else {
const int displayed_part = exact ? p : part_displayed_at( parts[p].mount.x, parts[p].mount.y );
if( displayed_part < 0 || displayed_part >= ( int )parts.size() ) {
return c_black;
}
if( parts[displayed_part].blood > 200 ) {
col = c_red;
} else if( parts[displayed_part].blood > 0 ) {
col = c_light_red;
} else if( parts[displayed_part].is_broken() ) {
col = part_info( displayed_part ).color_broken;
} else {
col = part_info( displayed_part ).color;
}
}
if( exact ) {
return col;
}
// curtains turn windshields gray
int curtains = part_with_feature( p, VPFLAG_CURTAIN, false );
if( curtains >= 0 ) {
if( part_with_feature( p, VPFLAG_WINDOW, true ) >= 0 && !parts[curtains].open ) {
col = part_info( curtains ).color;
}
}
//Invert colors for cargo parts with stuff in them
int cargo_part = part_with_feature( p, VPFLAG_CARGO );
if( cargo_part > 0 && !get_items( cargo_part ).empty() ) {
return invert_color( col );
} else {
return col;
}
}
void mt_part_dump(void)
{
part_t *part = partition;
part_info("Part Info.(1blk=%dB):\n", BLK_SIZE);
while (part->nr_sects) {
part_info("[0x%016llx-0x%016llx] (%.8ld blocks): \"%s\"\n",
(u64)part->start_sect * BLK_SIZE,
(u64)(part->start_sect + part->nr_sects) * BLK_SIZE - 1,
part->nr_sects, (part->info) ? part->info->name : "unknown");
part++;
}
part_info("\n");
}
char vehicle::part_sym( const int p, const bool exact ) const
{
if( p < 0 || p >= ( int )parts.size() || parts[p].removed ) {
return ' ';
}
const int displayed_part = exact ? p : part_displayed_at( parts[p].mount.x, parts[p].mount.y );
if( part_flag( displayed_part, VPFLAG_OPENABLE ) && parts[displayed_part].open ) {
return '\''; // open door
} else {
return parts[ displayed_part ].is_broken() ?
part_info( displayed_part ).sym_broken : part_info( displayed_part ).sym;
}
}
static int upgrade_handler(struct partition_package *package, int size)
{
int err;
part_info("upgrade_handler: \n");
//1. check parameter valid, unpack data
err = valid_package(package, size);
if (err) {
goto out;
}
//2. update PGPT/SGPT
err = update_partition_table(package);
if (err) {
goto out;
}
#if 1
//3. update disk info
err = reload_partition_table();
if (err) {
goto out;
}
#endif
out:
//fail_malloc:
return err;
}
int main(int, char **)
{
DayNum_t today = DateLUT::instance().toDayNum(time(nullptr));
for (DayNum_t date = today; DayNum_t(date + 10) > today; --date)
{
DB::MergeTreePartInfo part_info("partition", 0, 0, 0);
std::string name = part_info.getPartNameV0(date, date);
std::cerr << name << '\n';
time_t time = DateLUT::instance().YYYYMMDDToDate(DB::parse<UInt32>(name));
std::cerr << LocalDateTime(time) << '\n';
}
return 0;
}
void two_sort(int start,int end)
{
int i= 0;
if(start < end){
int mid = (start + end)/2;
two_sort(start,mid);
two_sort(mid+1,end);
for(i = 0;i < 8; i++){
printf("%d ",a[i]);
}
putchar ('\n');
part_info(start,mid,end);
for(i = 0;i < 8; i++){
printf("%d ",a[i]);
}
putchar ('\n');
}
}
part_t* get_part(char *name)
{
part_t *part = partition;
part_t *ret = NULL;
part_info("%s[%s] %s\n", TAG, __FUNCTION__, name);
while (part->nr_sects) {
if (part->info) {
if (!strcmp(name, (char *)part->info->name)) {
memcpy(&tempart, part, sizeof(part_t));
memcpy(&temmeta, part->info, sizeof(struct part_meta_info));
tempart.info = &temmeta;
ret = &tempart;
break;
}
}
part++;
//part_info("%s[%s] 0x%lx\n", TAG, __FUNCTION__, tempart.start_sect);
}
return ret;
}
static int get_partition_package(struct gendisk *disk, struct partition_package *package)
{
struct part_t *pinfo;
struct disk_part_iter piter;
struct hd_struct *part;
pinfo = (void*)package + sizeof(*package);
disk_part_iter_init(&piter, disk, 0);
while ((part = disk_part_iter_next(&piter))) {
pinfo->start = (unsigned long)part->start_sect * 512;
pinfo->size = (unsigned long)part->nr_sects * 512;
pinfo->part_id = EMMC_PART_USER;
if (part->info) {
memcpy(pinfo->name, part->info->volname, 64);
}
part_info("%-16s: 0x%016llx, 0x%016llx\n", pinfo->name, pinfo->start, pinfo->size);
pinfo++;
}
disk_part_iter_exit(&piter);
return 0;
}
static PetscErrorCode MatPartitioningApply_Party(MatPartitioning part, IS * partitioning)
{
PetscErrorCode ierr;
int *locals, *parttab = NULL, rank, size;
Mat mat = part->adj, matMPI, matSeq;
int nb_locals;
Mat_MPIAdj *adj = (Mat_MPIAdj *) mat->data;
MatPartitioning_Party *party = (MatPartitioning_Party *) part->data;
PetscTruth flg;
#ifdef PETSC_HAVE_UNISTD_H
int fd_stdout, fd_pipe[2], count,err;
#endif
PetscFunctionBegin;
/* check if the matrix is sequential, use MatGetSubMatrices if necessary */
ierr = PetscTypeCompare((PetscObject) mat, MATMPIADJ, &flg);CHKERRQ(ierr);
ierr = MPI_Comm_size(((PetscObject)mat)->comm, &size);CHKERRQ(ierr);
ierr = MPI_Comm_rank(((PetscObject)part)->comm, &rank);CHKERRQ(ierr);
if (size > 1) {
int M, N;
IS isrow, iscol;
Mat *A;
if (flg) SETERRQ(PETSC_ERR_SUP,"Distributed matrix format MPIAdj is not supported for sequential partitioners");
ierr = PetscPrintf(((PetscObject)part)->comm,"Converting distributed matrix to sequential: this could be a performance loss\n");CHKERRQ(ierr);
ierr = MatGetSize(mat, &M, &N);CHKERRQ(ierr);
ierr = ISCreateStride(PETSC_COMM_SELF, M, 0, 1, &isrow);CHKERRQ(ierr);
ierr = ISCreateStride(PETSC_COMM_SELF, N, 0, 1, &iscol);CHKERRQ(ierr);
ierr = MatGetSubMatrices(mat, 1, &isrow, &iscol, MAT_INITIAL_MATRIX, &A);CHKERRQ(ierr);
ierr = ISDestroy(isrow);CHKERRQ(ierr);
ierr = ISDestroy(iscol);CHKERRQ(ierr);
matSeq = *A;
ierr = PetscFree(A);CHKERRQ(ierr);
} else {
matSeq = mat;
}
/* check for the input format that is supported only for a MPIADJ type
and set it to matMPI */
if (!flg) {
ierr = MatConvert(matSeq, MATMPIADJ, MAT_INITIAL_MATRIX, &matMPI);CHKERRQ(ierr);
} else {
matMPI = matSeq;
}
adj = (Mat_MPIAdj *) matMPI->data; /* finaly adj contains adjacency graph */
{
/* Party library arguments definition */
int n = mat->rmap->N; /* number of vertices in full graph */
int *edge_p = adj->i; /* start of edge list for each vertex */
int *edge = adj->j; /* edge list data */
int *vertex_w = NULL; /* weights for all vertices */
int *edge_w = NULL; /* weights for all edges */
float *x = NULL, *y = NULL, *z = NULL; /* coordinates for inertial method */
int p = part->n; /* number of parts to create */
int *part_party; /* set number of each vtx (length n) */
int cutsize; /* number of edge cut */
char *global = party->global_method; /* global partitioning algorithm */
char *local = party->local_method; /* local partitioning algorithm */
int redl = party->nbvtxcoarsed; /* how many vertices to coarsen down to? */
char *redm = party->redm;
char *redo = party->redo;
int rec = party->rec;
int output = party->output;
ierr = PetscMalloc((mat->rmap->N) * sizeof(int), &part_party);CHKERRQ(ierr);
/* redirect output to buffer party->mesg_log */
#ifdef PETSC_HAVE_UNISTD_H
fd_stdout = dup(1);
pipe(fd_pipe);
close(1);
dup2(fd_pipe[1], 1);
ierr = PetscMalloc(SIZE_LOG * sizeof(char), &(party->mesg_log));CHKERRQ(ierr);
#endif
/* library call */
party_lib_times_start();
ierr = party_lib(n, vertex_w, x, y, z, edge_p, edge, edge_w,
p, part_party, &cutsize, redl, redm, redo,
global, local, rec, output);
party_lib_times_output(output);
part_info(n, vertex_w, edge_p, edge, edge_w, p, part_party, output);
#ifdef PETSC_HAVE_UNISTD_H
err = fflush(stdout);
if (err) SETERRQ(PETSC_ERR_SYS,"fflush() failed on stdout");
count =
read(fd_pipe[0], party->mesg_log, (SIZE_LOG - 1) * sizeof(char));
if (count < 0)
count = 0;
party->mesg_log[count] = 0;
close(1);
dup2(fd_stdout, 1);
close(fd_stdout);
close(fd_pipe[0]);
close(fd_pipe[1]);
#endif
/* if in the call we got an error, we say it */
if (ierr) SETERRQ(PETSC_ERR_LIB, party->mesg_log);
parttab = part_party;
}
/* Creation of the index set */
ierr = MPI_Comm_rank(((PetscObject)part)->comm, &rank);CHKERRQ(ierr);
ierr = MPI_Comm_size(((PetscObject)part)->comm, &size);CHKERRQ(ierr);
nb_locals = mat->rmap->N / size;
locals = parttab + rank * nb_locals;
if (rank < mat->rmap->N % size) {
nb_locals++;
locals += rank;
} else {
locals += mat->rmap->N % size;
}
ierr = ISCreateGeneral(((PetscObject)part)->comm, nb_locals, locals, partitioning);CHKERRQ(ierr);
/* destroying old objects */
ierr = PetscFree(parttab);CHKERRQ(ierr);
if (matSeq != mat) {
ierr = MatDestroy(matSeq);CHKERRQ(ierr);
}
if (matMPI != mat) {
ierr = MatDestroy(matMPI);CHKERRQ(ierr);
}
PetscFunctionReturn(0);
}
/**
* Prints a list of all parts to the screen inside of a boxed window, possibly
* highlighting a selected one.
* @param win The window to draw in.
* @param y1 The y-coordinate to start drawing at.
* @param max_y Draw no further than this y-coordinate.
* @param width The width of the window.
* @param p The index of the part being examined.
* @param hl The index of the part to highlight (if any).
*/
int vehicle::print_part_list( const catacurses::window &win, int y1, const int max_y, int width,
int p, int hl /*= -1*/ ) const
{
if( p < 0 || p >= ( int )parts.size() ) {
return y1;
}
std::vector<int> pl = this->parts_at_relative( parts[p].mount.x, parts[p].mount.y );
int y = y1;
for( size_t i = 0; i < pl.size(); i++ ) {
if( y >= max_y ) {
mvwprintz( win, y, 1, c_yellow, _( "More parts here..." ) );
++y;
break;
}
const vehicle_part &vp = parts[ pl [ i ] ];
nc_color col_cond = vp.is_broken() ? c_dark_gray : vp.base.damage_color();
std::string partname = vp.name();
if( vp.is_fuel_store() && vp.ammo_current() != "null" ) {
partname += string_format( " (%s)", item::nname( vp.ammo_current() ).c_str() );
}
if( part_flag( pl[i], "CARGO" ) ) {
//~ used/total volume of a cargo vehicle part
partname += string_format( _( " (vol: %s/%s %s)" ),
format_volume( stored_volume( pl[i] ) ).c_str(),
format_volume( max_volume( pl[i] ) ).c_str(),
volume_units_abbr() );
}
bool armor = part_flag( pl[i], "ARMOR" );
std::string left_sym;
std::string right_sym;
if( armor ) {
left_sym = "(";
right_sym = ")";
} else if( part_info( pl[i] ).location == part_location_structure ) {
left_sym = "[";
right_sym = "]";
} else {
left_sym = "-";
right_sym = "-";
}
nc_color sym_color = ( int )i == hl ? hilite( c_light_gray ) : c_light_gray;
mvwprintz( win, y, 1, sym_color, left_sym );
trim_and_print( win, y, 2, getmaxx( win ) - 4,
( int )i == hl ? hilite( col_cond ) : col_cond, partname );
wprintz( win, sym_color, right_sym );
if( i == 0 && vpart_position( const_cast<vehicle &>( *this ), pl[i] ).is_inside() ) {
//~ indicates that a vehicle part is inside
mvwprintz( win, y, width - 2 - utf8_width( _( "Interior" ) ), c_light_gray, _( "Interior" ) );
} else if( i == 0 ) {
//~ indicates that a vehicle part is outside
mvwprintz( win, y, width - 2 - utf8_width( _( "Exterior" ) ), c_light_gray, _( "Exterior" ) );
}
y++;
}
// print the label for this location
const cata::optional<std::string> label = vpart_position( const_cast<vehicle &>( *this ),
p ).get_label();
if( label && y <= max_y ) {
mvwprintz( win, y++, 1, c_light_red, _( "Label: %s" ), label->c_str() );
}
return y;
}
static PetscErrorCode MatPartitioningApply_Party(MatPartitioning part,IS *partitioning)
{
PetscErrorCode ierr;
PetscInt i,*parttab,*locals,nb_locals,M,N;
PetscMPIInt size,rank;
Mat mat = part->adj,matAdj,matSeq,*A;
Mat_MPIAdj *adj;
MatPartitioning_Party *party = (MatPartitioning_Party*)part->data;
PetscBool flg;
IS isrow, iscol;
int n,*edge_p,*edge,*vertex_w,p,*part_party,cutsize,redl,rec;
const char *redm,*redo;
char *mesg_log;
#if defined(PETSC_HAVE_UNISTD_H)
int fd_stdout,fd_pipe[2],count,err;
#endif
PetscFunctionBegin;
ierr = MPI_Comm_size(PetscObjectComm((PetscObject)mat),&size);CHKERRQ(ierr);
ierr = MPI_Comm_rank(PetscObjectComm((PetscObject)mat),&rank);CHKERRQ(ierr);
ierr = PetscObjectTypeCompare((PetscObject)mat,MATMPIADJ,&flg);CHKERRQ(ierr);
if (size>1) {
if (flg) SETERRQ(PetscObjectComm((PetscObject)mat),PETSC_ERR_SUP,"Distributed matrix format MPIAdj is not supported for sequential partitioners");
ierr = PetscInfo(part,"Converting distributed matrix to sequential: this could be a performance loss\n");CHKERRQ(ierr);
ierr = MatGetSize(mat,&M,&N);CHKERRQ(ierr);
ierr = ISCreateStride(PETSC_COMM_SELF,M,0,1,&isrow);CHKERRQ(ierr);
ierr = ISCreateStride(PETSC_COMM_SELF,N,0,1,&iscol);CHKERRQ(ierr);
ierr = MatGetSubMatrices(mat,1,&isrow,&iscol,MAT_INITIAL_MATRIX,&A);CHKERRQ(ierr);
ierr = ISDestroy(&isrow);CHKERRQ(ierr);
ierr = ISDestroy(&iscol);CHKERRQ(ierr);
matSeq = *A;
ierr = PetscFree(A);CHKERRQ(ierr);
} else {
ierr = PetscObjectReference((PetscObject)mat);CHKERRQ(ierr);
matSeq = mat;
}
if (!flg) { /* convert regular matrix to MPIADJ */
ierr = MatConvert(matSeq,MATMPIADJ,MAT_INITIAL_MATRIX,&matAdj);CHKERRQ(ierr);
} else {
ierr = PetscObjectReference((PetscObject)matSeq);CHKERRQ(ierr);
matAdj = matSeq;
}
adj = (Mat_MPIAdj*)matAdj->data; /* finaly adj contains adjacency graph */
/* arguments for Party library */
n = mat->rmap->N; /* number of vertices in full graph */
edge_p = adj->i; /* start of edge list for each vertex */
edge = adj->j; /* edge list data */
vertex_w = part->vertex_weights; /* weights for all vertices */
p = part->n; /* number of parts to create */
redl = party->nbvtxcoarsed; /* how many vertices to coarsen down to? */
rec = party->recursive ? 1 : 0; /* recursive bisection */
redm = party->redm ? "lam" : ""; /* matching method */
redo = party->redo ? "w3" : ""; /* matching optimization method */
ierr = PetscMalloc1(mat->rmap->N,&part_party);CHKERRQ(ierr);
/* redirect output to buffer */
#if defined(PETSC_HAVE_UNISTD_H)
fd_stdout = dup(1);
if (pipe(fd_pipe)) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SYS,"Could not open pipe");
close(1);
dup2(fd_pipe[1],1);
ierr = PetscMalloc1(SIZE_LOG,&mesg_log);CHKERRQ(ierr);
#endif
/* library call */
party_lib_times_start();
ierr = party_lib(n,vertex_w,NULL,NULL,NULL,edge_p,edge,NULL,p,part_party,&cutsize,redl,(char*)redm,(char*)redo,party->global,party->local,rec,1);
party_lib_times_output(1);
part_info(n,vertex_w,edge_p,edge,NULL,p,part_party,1);
#if defined(PETSC_HAVE_UNISTD_H)
err = fflush(stdout);
if (err) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SYS,"fflush() failed on stdout");
count = read(fd_pipe[0],mesg_log,(SIZE_LOG-1)*sizeof(char));
if (count<0) count = 0;
mesg_log[count] = 0;
close(1);
dup2(fd_stdout,1);
close(fd_stdout);
close(fd_pipe[0]);
close(fd_pipe[1]);
if (party->verbose) {
ierr = PetscPrintf(PetscObjectComm((PetscObject)mat),mesg_log);
}
ierr = PetscFree(mesg_log);CHKERRQ(ierr);
#endif
if (ierr) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_LIB,"Party failed");
ierr = PetscMalloc1(mat->rmap->N,&parttab);CHKERRQ(ierr);
for (i=0; i<mat->rmap->N; i++) parttab[i] = part_party[i];
/* creation of the index set */
nb_locals = mat->rmap->N / size;
locals = parttab + rank*nb_locals;
if (rank < mat->rmap->N % size) {
nb_locals++;
locals += rank;
} else locals += mat->rmap->N % size;
ierr = ISCreateGeneral(PetscObjectComm((PetscObject)part),nb_locals,locals,PETSC_COPY_VALUES,partitioning);CHKERRQ(ierr);
/* clean up */
ierr = PetscFree(parttab);CHKERRQ(ierr);
ierr = PetscFree(part_party);CHKERRQ(ierr);
ierr = MatDestroy(&matSeq);CHKERRQ(ierr);
ierr = MatDestroy(&matAdj);CHKERRQ(ierr);
PetscFunctionReturn(0);
}