void templateAppInit(int width, int height)
{
GFX_start();
glViewport(0.0f, 0.0f, width, height);
GFX_set_matrix_mode(PROJECTION_MATRIX);
{
float half_width = (float)width * 0.5f, half_height = (float)height *0.5f;
GFX_load_identity();
GFX_set_orthographic_2d(-half_width, half_width, -half_height, half_height);
GFX_translate(-half_width, -half_height, 0.0f);
glDisable(GL_DEPTH_TEST);
glDepthMask(GL_FALSE);
}
program = PROGRAM_init((char *)"default");
program->vertex_shader = SHADER_init(VERTEX_SHADER, GL_VERTEX_SHADER);
program->fragment_shader = SHADER_init(FRAGMENT_SHADER, GL_FRAGMENT_SHADER);
m = mopen(VERTEX_SHADER, 1);
if (m) {
if (!SHADER_compile(program->vertex_shader, (char *)m->buffer, DEBUG_SHADERS))
exit(1);
}
m = mclose(m);
m = mopen(FRAGMENT_SHADER, 1);
if (m) {
if (!SHADER_compile(program->fragment_shader, (char *)m->buffer, DEBUG_SHADERS))
exit(2);
}
m = mclose(m);
if (!PROGRAM_link(program, DEBUG_SHADERS))
exit(3);
}
/**
** @brief Closes all file descriptors opened by call.
** @param fd_in Input filedes.
** @param filedes File descriptor list.
** @param ptr Check to NULL pointer.
** @return void
*/
static void close_fds(int *fd_in,
int *filedes,
void *ptr)
{
if (*fd_in != STDIN_FILENO)
mclose(*fd_in);
if (ptr != NULL)
mclose(filedes[1]);
*fd_in = filedes[0];
}
void templateAppInit( int width, int height )
{
atexit( templateAppExit );
GFX_start();
glViewport( 0.0f, 0.0f, width, height );
GFX_set_matrix_mode( PROJECTION_MATRIX );
{
GFX_load_identity();
//设置为透视投影
GFX_set_perspective( 45.0f,
( float )width / ( float )height,
0.01f,
100.0f,
0.0f );
//角度越大，视角范围越宽广，相反，角度越小媒，投影也越窄
glDisable( GL_CULL_FACE );
}
program = PROGRAM_init( ( char * )"default" );
program->vertex_shader = SHADER_init( VERTEX_SHADER, GL_VERTEX_SHADER );
program->fragment_shader = SHADER_init( FRAGMENT_SHADER, GL_FRAGMENT_SHADER );
m = mopen( VERTEX_SHADER, 1 );
if( m ) {
if( !SHADER_compile( program->vertex_shader,
( char * )m->buffer,
DEBUG_SHADERS ) ) exit( 1 );
}
m = mclose( m );
m = mopen( FRAGMENT_SHADER, 1 );
if( m ) {
if( !SHADER_compile( program->fragment_shader,
( char * )m->buffer,
DEBUG_SHADERS ) ) exit( 2 );
}
m = mclose( m );
if( !PROGRAM_link( program, DEBUG_SHADERS ) ) exit( 3 );
}
void templateAppInit(int width, int height)
{
GFX_start();
glViewport(0.0f, 0.0f, width, height);
GFX_set_matrix_mode(PROJECTION_MATRIX);
GFX_load_identity();
GFX_set_perspective(45.0f, (float)width / (float)height, 0.1f, 100.0f, -90.0f);
obj = OBJ_load(OBJ_FILE, 1);
unsigned int i = 0;
while (i != obj->n_objmesh) {
OBJ_build_mesh(obj, i);
OBJ_free_mesh_vertex_data(obj, i);
++i;
}
i = 0;
while (i != obj->n_texture) {
OBJ_build_texture(obj, i, obj->texture_path, TEXTURE_MIPMAP, TEXTURE_FILTER_2X, 0.0f);
++i;
}
i = 0;
while (i != obj->n_objmaterial) {
MEMORY *fragment_shader = mopen((char *)"fragment.glsl", 1);
MEMORY *vertex_shader = mopen((char *)"vertex.glsl", 1);
OBJMATERIAL *objmaterial = &obj->objmaterial[i];
OBJ_build_material(obj, i, NULL);
if (objmaterial->dissolve == 1.0f)
minsert(fragment_shader, (char *)"#define SOLID_OBJECT\n", 0);
else if (!objmaterial->dissolve)
minsert(fragment_shader, (char *)"#define ALPHA_TESTED_OBJECT\n", 0);
else
minsert(fragment_shader, (char *)"#define TRANSPARENT_OBJECT\n", 0);
if (objmaterial->illumination_model) {
minsert(vertex_shader, (char *)"#define LIGHTING_SHADER\n", 0);
minsert(fragment_shader, (char *)"#define LIGHTING_SHADER\n", 0);
}
objmaterial->program = PROGRAM_init(objmaterial->name);
objmaterial->program->vertex_shader = SHADER_init((char *)"vertex", GL_VERTEX_SHADER);
objmaterial->program->fragment_shader = SHADER_init((char *)"fragment", GL_FRAGMENT_SHADER);
SHADER_compile(objmaterial->program->vertex_shader, (char *)vertex_shader->buffer, 1);
SHADER_compile(objmaterial->program->fragment_shader, (char *)fragment_shader->buffer, 1);
PROGRAM_set_bind_attrib_location_callback(objmaterial->program, program_bind_attrib_location);
PROGRAM_link(objmaterial->program, 1);
OBJ_set_draw_callback_material(obj, i, material_draw_callback);
mclose(fragment_shader);
mclose(vertex_shader);
++i;
}
}
int mcloseAll()
{
int iFileCount = FileManager::getFileMaxID();
for (int i = iFileCount - 1 ; i >= 0 ; i--)
{
switch (i)
{
case 0: // stderr
case 5: // stdin
case 6: // stdout
continue;
break;
default :
if (FileManager::getFile(i) != NULL)
{
//call mclose only for existing opened files.
int iRet = mclose(i);
if (iRet)
{
return iRet;
}
}
}
}
return 0;
}
void clean_child_st(int i)
{
if (child_st[i].client_fd != -1) {
close(child_st[i].client_fd);
child_st[i].client_fd = -1;
}
if (child_st[i].pipe_r_in != -1) {
close(child_st[i].pipe_r_in);
child_st[i].pipe_r_in = -1;
}
if (child_st[i].pipe_r_out != -1) {
close(child_st[i].pipe_r_out);
child_st[i].pipe_r_out = -1;
}
if (child_st[i].pipe_w_out != -1) {
close(child_st[i].pipe_w_out);
child_st[i].pipe_w_out = -1;
}
if (child_st[i].pipe_w_in != -1) {
close(child_st[i].pipe_w_in);
child_st[i].pipe_w_in = -1;
}
child_st[i].pid = -1;
child_st[i].used = 0;
memset(child_st[i].mid, 0, sizeof(child_st[i].mid));
if (child_st[i].mfp_out != NULL) {
mclose(child_st[i].mfp_out);
child_st[i].mfp_out = NULL;
}
}
int main(){
Color black = make_color(0, 0, 0);
MMC mmc, *mp;
IMG img, *ip;
while(1){
mmc = mopen(), mp = &mmc;
mseek(mp, PROGRAM_SIZE, SEEK_CUR);
img = iopen(mp), ip = &img;
draw_clear(&black);
draw_img(ip);
while(1){
if(check_switch(SWITCH1, ON)){
if(seek_next_img(ip)){
mclose(mp);
break;
}
draw_img(ip);
}
}
}
}
void mopen( short n, short row, short col, short width, short height, char * title )
{
// if (n==0) return;
if (! mono_present()) return; //error! no mono card
if (OPEN) mclose(n);
OPEN = 1;
ROW = row;
COL = col;
WIDTH = width;
HEIGHT = height;
for (row=-1; row<HEIGHT+1; row++ )
for (col=-1; col<WIDTH+1; col++ ) {
CHAR(row,col) = 32;
ATTR(row,col) = 7;
XCHAR(row,col) = 32;
XATTR(row,col) = 7;
}
drawbox(n);
CROW=-1; CCOL=0;
mprintf( n, title );
CROW=0; CCOL=0;
msetcursor( ROW+CROW, COL+CCOL );
}
void check_bootfree_and_update(LPCALC lpCalc) {
u_char *bootFreeString = lpCalc->mem_c.flash + (lpCalc->mem_c.flash_pages - 1) * PAGE_SIZE + 0x0F;
if (*bootFreeString != '1') {
//not using bootfree
return;
}
if (bootFreeString[1] == '.') {
//using normal bootpage
return;
}
if (!strcmp((const char *) bootFreeString, BOOTFREE_VER)) {
return;
}
#ifdef WINVER
TCHAR hexFile[MAX_PATH];
ExtractBootFree(lpCalc->model, hexFile);
FILE *file;
_tfopen_s(&file, hexFile, _T("rb"));
writeboot(file, &lpCalc->mem_c, -1);
fclose(file);
_tfopen_s(&file, lpCalc->rom_path, _T("wb"));
if (file) {
fclose(file);
MFILE *mfile = ExportRom(lpCalc->rom_path, lpCalc);
mclose(mfile);
}
#endif
}
/**
* slib-manager: close everything
*/
void sblmgr_close() {
#if defined(LNX_EXTLIB) || defined(WIN_EXTLIB)
int i;
slib_t *lib;
void (*mclose) (void);
for (i = 0; i < slib_count; i++) {
lib = &slib_table[i];
if (lib->handle) {
mclose = slib_getoptptr(lib, "sblib_close");
if (mclose) {
mclose();
}
slib_llclose(lib);
}
}
if (slib_count) {
slib_count = 0;
extproctable = NULL;
extprocsize = 0;
extproccount = 0;
extfunctable = NULL;
extfuncsize = 0;
extfunccount = 0;
}
#endif
}
void unload_terrain_3d_tree_database ( void )
{
int
x_sector,
z_sector;
if ( terrain_tree_sectors )
{
mclose ( terrain_tree_database );
for ( z_sector = 0; z_sector < terrain_3d_sector_z_max; z_sector++ )
{
for ( x_sector = 0; x_sector < terrain_3d_sector_z_max; x_sector++ )
{
terrain_tree_sectors[z_sector][x_sector].number_of_trees = 0;
terrain_tree_sectors[z_sector][x_sector].data = NULL;
}
}
}
}
int main(int argc, char *argv[])
{
int do_restore = argc > 1 && strcmp("-r", argv[1]) == 0;
const char *mode = (do_restore) ? "r+" : "w+";
/* call perm() and open() before malloc() */
perm(PERM_START, PERM_SIZE);
mopen(MMAP_FILE, mode, MMAP_SIZE);
bopen(BACK_FILE, mode);
if (do_restore) {
restore();
} else {
home = (home_st *)malloc(sizeof(home_st));
/* initialize home struct... */
mflush(); backup();
}
for (;/* each step */;) {
/* Application_Step(); */
backup();
}
free(home);
mclose();
bclose();
return(0);
}
void load_physic_world( void )
{
btBulletWorldImporter *btbulletworldimporter = new btBulletWorldImporter( dynamicsworld );
MEMORY *memory = mopen( PHYSIC_FILE, 1 );
btbulletworldimporter->loadFileFromMemory( ( char * )memory->buffer, memory->size );
mclose( memory );
unsigned int i = 0;
while( i != btbulletworldimporter->getNumRigidBodies() ) {
OBJMESH *objmesh = OBJ_get_mesh( obj,
btbulletworldimporter->getNameForPointer(
btbulletworldimporter->getRigidBodyByIndex( i ) ), 0 );
if( objmesh ) {
objmesh->btrigidbody = ( btRigidBody * )btbulletworldimporter->getRigidBodyByIndex( i );
objmesh->btrigidbody->setUserPointer( objmesh );
}
++i;
}
delete btbulletworldimporter;
}
/*
* Class: com_Revsoft_Wabbitemu_CalcInterface
* Method: CreateRom
* Signature: (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V
*/
JNIEXPORT jint JNICALL Java_com_Revsoft_Wabbitemu_calc_CalcInterface_CreateRom
(JNIEnv *env, jclass classObj, jstring jOsPath, jstring jBootPath,
jstring jRomPath, jint model) {
checkThread();
const char *osPath = env->GetStringUTFChars(jOsPath, JNI_FALSE);
const char *bootPath = env->GetStringUTFChars(jBootPath, JNI_FALSE);
const char *romPath = env->GetStringUTFChars(jRomPath, JNI_FALSE);
//Do not allow more than one calc currently
if (lpCalc) {
calc_slot_free(lpCalc);
}
lpCalc = calc_slot_new();
calc_init_model(lpCalc, model, NULL);
//slot stuff
strcpy(lpCalc->rom_path, romPath);
lpCalc->active = TRUE;
lpCalc->model = (CalcModel) model;
lpCalc->cpu.pio.model = model;
FILE *file = fopen(bootPath, "rb");
if (file == NULL) {
calc_slot_free(lpCalc);
lpCalc = NULL;
return -1;
}
writeboot(file, &lpCalc->mem_c, -1);
fclose(file);
remove(bootPath);
TIFILE_t *tifile = importvar(osPath, FALSE);
if (tifile == NULL) {
calc_slot_free(lpCalc);
lpCalc = NULL;
return -2;
}
int link_error = forceload_os(&lpCalc->cpu, tifile);
if (link_error != LERR_SUCCESS) {
calc_slot_free(lpCalc);
lpCalc = NULL;
return -2;
}
calc_erase_certificate(lpCalc->mem_c.flash,lpCalc->mem_c.flash_size);
calc_reset(lpCalc);
//write the output from file
MFILE *romfile = ExportRom((char *) romPath, lpCalc);
if (romfile != NULL) {
mclose(romfile);
calc_slot_free(lpCalc);
lpCalc = NULL;
return 0;
}
calc_slot_free(lpCalc);
lpCalc = NULL;
return -3;
}
int fast_write(MFILE *mfp, char *buf, size_t buf_len)
{
int wr = mwrite(mfp, buf, buf_len);
if (wr != 1) {
mclose(mfp);
mfp = NULL;
return 0;
}
return wr;
}
void DeInitCsdChannel(void)
{
mclose(cicsdstubsockfd);
cicsdstubsockfd = -1;
if (ciCsdRcvTaskRef)
send_sig(SIGSTOP, ciCsdRcvTaskRef, 1);
//kthread_stop(ciCsdRcvTaskRef);
if (ciCsdInitTaskRef)
kthread_stop(ciCsdInitTaskRef);
}
static apr_socket_t* mconnect(request_rec *r)
{
apr_status_t rv;
process_rec *p = r->connection->base_server->process;
if (s != NULL)
return s;
rv = apr_socket_create(&s, APR_INET, SOCK_STREAM, APR_PROTO_TCP, p->pool);
if (rv != APR_SUCCESS) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r, "socket creation failed");
mclose(r);
return NULL;
}
rv = apr_socket_opt_set(s, APR_SO_KEEPALIVE, 1);
if (rv != APR_SUCCESS) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r, "setting socket options");
mclose(r);
return NULL;
}
rv = apr_sockaddr_info_get(&addr, "localhost", APR_INET, 7777, 0, p->pool);
if (rv != APR_SUCCESS) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r, "addr resolution failed");
mclose(r);
return NULL;
}
rv = apr_socket_connect(s, addr);
if (rv != APR_SUCCESS) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r, "socket connect failed");
mclose(r);
return NULL;
}
return s;
}
void free_level( void )
{
gem_points =
game_state = 0;
game_time = 0.0f;
unsigned int i = 0;
/* Pause the thread, because we donÕt want the process to
* continue to decompress while we are trying to free the background music.
* That would make the app to crash for sure.
*/
THREAD_pause( thread );
/* Free the background sound source. */
background_sound = SOUND_free( background_sound );
/* Because the background music was streamed, free the sound buffer from
the local memory structure. */
background_soundbuffer->memory = mclose( background_soundbuffer->memory );
/* It is now okay to free the sound buffer. */
background_soundbuffer = SOUNDBUFFER_free( background_soundbuffer );
while( i != 4 ) {
/* Free the sound source and the associated buffer. */
gems_sound[ i ] = SOUND_free( gems_sound[ i ] );
gems_soundbuffer[ i ] = SOUNDBUFFER_free( gems_soundbuffer[ i ] );
++i;
}
/* Now deal with the water, lava, and toxic stuff sound sources and buffers. */
water_sound = SOUND_free( water_sound );
water_soundbuffer = SOUNDBUFFER_free( water_soundbuffer );
lava_sound = SOUND_free( lava_sound );
lava_soundbuffer = SOUNDBUFFER_free( lava_soundbuffer );
toxic_sound = SOUND_free( toxic_sound );
toxic_soundbuffer = SOUNDBUFFER_free( toxic_soundbuffer );
player = NULL;
THREAD_pause( thread );
font_small = FONT_free( font_small );
font_big = FONT_free( font_big );
free_physic_world();
obj = OBJ_free( obj );
}
BOOL safe_mclose (void *data)
{
BOOL
result;
ASSERT (data);
result = mclose (data);
ASSERT (result);
safe_memory_mapped_file_counter--;
return (result);
}
void free_level( void )
{
gem_points =
game_state = 0;
game_time = 0.0f;
unsigned int i = 0;
THREAD_pause( thread );
background_sound = SOUND_free( background_sound );
background_soundbuffer->memory = mclose( background_soundbuffer->memory );
background_soundbuffer = SOUNDBUFFER_free( background_soundbuffer );
while( i != 4 ) {
gems_sound[ i ] = SOUND_free( gems_sound[ i ] );
gems_soundbuffer[ i ] = SOUNDBUFFER_free( gems_soundbuffer[ i ] );
++i;
}
water_sound = SOUND_free( water_sound );
water_soundbuffer = SOUNDBUFFER_free( water_soundbuffer );
lava_sound = SOUND_free( lava_sound );
lava_soundbuffer = SOUNDBUFFER_free( lava_soundbuffer );
toxic_sound = SOUND_free( toxic_sound );
toxic_soundbuffer = SOUNDBUFFER_free( toxic_soundbuffer );
player = NULL;
THREAD_pause( thread );
font_small = FONT_free( font_small );
font_big = FONT_free( font_big );
free_physic_world();
obj = OBJ_free( obj );
}
void DeInitDataChannel(void)
{
#if 0
mclose(cidatastubsockfd);
cidatastubsockfd = -1;
if (ciDataRcvTaskRef) {
send_sig(SIGSTOP, ciDataRcvTaskRef, 1);
ciDataRcvTaskRef = NULL;
}
//kthread_stop(ciDataRcvTaskRef);
if (ciDataInitTaskRef) {
kthread_stop(ciDataInitTaskRef);
while (ciDataInitTaskRef)
msleep_interruptible(20);
}
#endif
}
static int mrecv(request_rec *r, char *msg, int *len)
{
apr_status_t rv;
apr_socket_t *s;
if ((s = mconnect(r)) == NULL)
return HTTP_INTERNAL_SERVER_ERROR;
if ((rv = apr_socket_recv(s, msg, len)) != APR_SUCCESS) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r, "recv failed");
mclose(r);
return HTTP_INTERNAL_SERVER_ERROR;
}
return OK;
}
void
lsb_merr(char *s)
{
char fname[] = "lsb_merr";
FILE *mail;
char *myhostnm;
if (lsb_CheckMode)
return;
if ((myhostnm = ls_getmyhostname()) == NULL) {
ls_syslog(LOG_ERR, I18N_FUNC_FAIL_MM, fname, "ls_getmyhostname");
if (masterme)
die(MASTER_FATAL);
else
die (SLAVE_FATAL);
}
if (lsbManager == NULL || (getpwnam(lsbManager)) == NULL) {
if (lsbManager == NULL)
ls_syslog(LOG_ERR, _i18n_msg_get(ls_catd , NL_SETN, 8601,
"%s: LSF administrator name is NULL"), /* catgets 8601 */
fname);
else
ls_syslog(LOG_ERR, _i18n_msg_get(ls_catd , NL_SETN, 8602,
"%s: Bad LSF administrator name <%s>"), /* catgets 8602 */
fname,
lsbManager);
if (masterme)
die (MASTER_FATAL);
else
die (SLAVE_FATAL);
}
mail = smail(lsbManager, myhostnm);
if (masterme)
fprintf(mail, _i18n_msg_get(ls_catd, NL_SETN, 3201,
"Subject: mbatchd on %s: %s\n"), /* catgets 3201 */
myhostnm, s);
else
fprintf(mail, _i18n_msg_get(ls_catd, NL_SETN, 3202,
"Subject: sbatchd on %s: %s\n"), /* catgets 3202 */
myhostnm, s);
mclose(mail);
}
int main() {
mount("volume2.vfs");
ls();
touch("ppg");
ls();
int fd;
fd = mopen("ppg");
char *out = mread(fd);
printf(out);
mclose(fd);
fd = mopen("ppg");
mwrite(fd, "spider man!");
mclose(fd);
fd = mopen("ppg");
out = mread(fd);
printf(out);
mclose(fd);
ls();
touch("hello.c");
ls();
fd = mopen("hello.c");
out = mread(fd);
printf(out);
mclose(fd);
fd = mopen("hello.c");
mwrite(fd, "hello\nworld!\n");
mclose(fd);
fd = mopen("hello.c");
out = mread(fd);
mclose(fd);
fd = mopen("ppg");
out = mread(fd);
printf(out);
mclose(fd);
umount();
return 0;
}
int hio_close(HIO_HANDLE *h)
{
int ret;
switch (HIO_HANDLE_TYPE(h)) {
case HIO_HANDLE_TYPE_FILE:
ret = fclose(h->handle.file);
break;
case HIO_HANDLE_TYPE_MEMORY:
ret = mclose(h->handle.mem);
break;
default:
ret = -1;
}
free(h);
return ret;
}
void deinitialise_file_system ( void )
{
int
count;
for ( count = 0; count < MAX_NUMBER_FILES; count++ )
{
if ( file_maps[count].used )
{
#if DEBUG_MODULE
debug_log ( "Memory mapped file %s not closed", file_maps[count].filename );
#endif
mclose ( file_maps[count].data );
}
}
}
void C2F(mclose) (int *fd, double *res)
{
int fd1 = -1;
*res = 0.0;
switch (*fd)
{
case ALL_FILES_DESCRIPTOR :
{
/* closing all opened files */
mcloseAll();
}
break;
default :
{
if (mclose(*fd))
{
*res = -1.0;
}
}
}
}
void
merr_user(char *user, char *host, char *msg, char *type)
{
char fname[] = "merr_user";
FILE *mail;
char *myhostnm;
if ((myhostnm = ls_getmyhostname()) == NULL) {
ls_syslog(LOG_ERR, I18N_FUNC_FAIL_MM, fname, "ls_getmyhostname");
die(MASTER_FATAL);
}
mail = smail(user, host);
fprintf(mail, _i18n_msg_get(ls_catd, NL_SETN, 3203,
"Subject: job %s report from %s\n"), /* catgets 3203 */
type,
myhostnm);
fprintf(mail, _i18n_msg_get(ls_catd, NL_SETN, 3204,
"\n\nDear %s,\n\n%s\n\n"), /* catgets 3204 */
user,
msg);
mclose(mail);
}
int main (int argc, char *argv[])
{
int my_rank, proc_num;
MPI_Status status;
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &proc_num);
MPI_Comm_rank(MPI_COMM_WORLD, &my_rank);
double diff; /* change in value */
int i, j, m, n;
int N=DEFAULT_N;
double epsilon=0.01;
double mean;
FILE *fp;
/* Argument processing */
int edgeElems = DEFAULT_ELEM; /* edge elements */
int cfreq = DEFAULT_FREQ; /* checkpoint frequency */
char *cpath = DEFAULT_PATH; /* checkpoint path */
int nok = 0; /* arguments not OK */
int pinit=1;
char *s;
while (--argc > 0 && (*++argv)[0] == '-') {
for(s=argv[0]+1;*s;s++)
switch (*s) {
case 'd':
if (isdigit(s[1]))
edgeElems = atoi(s+1);
else
nok = 1;
s+=strlen(s+1);
break;
case 'c':
if (isdigit(s[i]))
cfreq = atoi(s+1);
else
nok = 1;
s+=strlen(s+1);
break;
case 'p':
cpath = s+1;
s+=strlen(s+1);
break;
case 'r':
pinit = 0;
break;
case 'n':
if (isdigit(s[1]))
N = atoi(s+1);
else
nok = 1;
s+=strlen(s+1);
break;
case 'e':
if (isdigit(s[1]))
epsilon = atof(s+1);
else
nok = 1;
s+=strlen(s+1);
break;
default:
nok = 1;
break;
}
}
if (nok) {
fprintf(stderr, "Usage: %s -e<int> -c<int> -p<str> -r -n<int> -epsilon<double>\n", argv[0]);
fprintf(stderr, " -d edge elements, default: %d\n", DEFAULT_ELEM);
fprintf(stderr, " -c checkpoint frequency, default: %d\n", DEFAULT_FREQ);
fprintf(stderr, " -p path to checkpoint file, default: %s\n", DEFAULT_PATH);
fprintf(stderr, " -r restore\n");
fprintf(stderr, " -n size of n, default:1000\n");
fprintf(stderr, " -e epsilon, default:0.01\n");
exit(EXIT_FAILURE);
}
#ifdef DEBUG
if(my_rank==0)
printf("n=%d, epsilon=%lf\n", N, epsilon);
#endif
if(N>1000){
printf("Too big value for N, use no more than 1000, or change DEFAULT_N\n");
return 0;
}
// Persistent memory initialization
const char *mode = (pinit) ? "w+" : "r+";
char back_fname[128];
char my_rank_str[4];
perm(PERM_START, PERM_SIZE);
strcpy(back_fname, cpath);
strcat(back_fname,"hw5_mpi.back.");
sprintf(my_rank_str, "%d", my_rank);
strcat(back_fname,my_rank_str);
// printf("mopen: %s\n", back_fname);
mopen(back_fname, mode, MMAP_SIZE);
strcpy(back_fname, cpath);
strcat(back_fname,"hw5_mpi.mmap.");
strcat(back_fname,my_rank_str);
// printf("bopen: %s\n", back_fname);
bopen(back_fname, mode);
if (!pinit){
restore();
printf("Resotored, iter=%d, myN=%d\n", iter, myN);
}
else{
iter = 0;
/* Set boundary values and compute mean boundary value */
mean = 0.0;
for (i=0; i<N; i++) {
u[i][0] = u[i][N-1] = u[0][i] = 100.0;
u[N-1][i] = 0.0;
mean += u[i][0] + u[i][N-1] + u[0][i] + u[N-1][i];
}
mean /= (4.0 *N);
/* Initialize interior values */
for (i =1; i<N-1; i++)
for (j=1; j<N-1; j++)
u[i][j] = mean;
// distribute data
myN = N / proc_num;
if(N%proc_num!=0){
if(my_rank==proc_num-1)
myN=N-(proc_num-1)*myN;
}
if(proc_num > 1) {
// ghost rows
if(my_rank == 0 || my_rank == proc_num - 1)
myN++;
else
myN += 2;
}
// initial value
for(i = 0; i < myN; i++) {
for(j = 0; j < N; j++) {
if(my_rank == 0)
myu[i][j] = u[i][j];
else
myu[i][j] = u[my_rank*(N/proc_num)-1+i][j];
myw[i][j]=myu[i][j];
}
}
mflush();
backup();
}
struct timeval start_tv, end_tv;
gettimeofday(&start_tv, NULL);
double alldiff=0;
int left = my_rank - 1;
int right = my_rank +1;
MPI_Request send_req1, recv_req1;
MPI_Request send_req2, recv_req2;
while(1)
{
iter++;
diff = 0.0;
for (i=1; i<myN-1; i++) {
for (j=1; j<N-1; j++) {
myw[i][j] = (myu[i-1][j] + myu[i+1][j] + myu[i][j-1] + myu[i][j+1])/4.0;
if (fabs (myw[i][j] - myu[i][j]) > diff)
diff = fabs(myw[i][j] - myu[i][j]);
}
}
// reduce diff
MPI_Allreduce(&diff, &alldiff, 1, MPI_DOUBLE, MPI_MAX, MPI_COMM_WORLD);
#ifdef PRINTITER
if(my_rank==0){
printf("iter=%d, diff=%lf\n", iter, alldiff);
fflush(stdout);
}
#endif
if (alldiff <= epsilon)
break;
if(proc_num > 1) {
// send second top row
if(my_rank != 0){
MPI_Isend(myw[1], N, MPI_DOUBLE, left, 0, MPI_COMM_WORLD, &send_req1);
//printf("Send: %d->%d\n", my_rank, left);
}
// send second to bottom row
if(my_rank != proc_num - 1){
MPI_Isend(myw[myN-2], N, MPI_DOUBLE, right, 1, MPI_COMM_WORLD, &send_req2);
//printf("Send %d->%d\n", my_rank, right);
}
// recive top
if(my_rank != 0){
MPI_Irecv(myw[0], N, MPI_DOUBLE, left, 1, MPI_COMM_WORLD, &recv_req1);
//printf("Recv: %d->%d\n", my_rank, left);
}
// receive bottom
if(my_rank != proc_num - 1) {
MPI_Irecv(myw[myN-1], N, MPI_DOUBLE, right, 0, MPI_COMM_WORLD, &recv_req2);
//printf("Recv %d->%d\n", my_rank, right);
}
if(my_rank != 0)
MPI_Wait(&send_req1, &status);
if(my_rank != proc_num - 1)
MPI_Wait(&send_req2, &status);
if(my_rank != 0)
MPI_Wait(&recv_req1, &status);
if(my_rank != proc_num - 1)
MPI_Wait(&recv_req2, &status);
}
for (i=0; i<myN; i++) {
if( (i==0&&my_rank==0) ||(i==myN-1&&my_rank==proc_num-1))
continue;
for (j=1; j<N-1; j++)
myu[i][j] = myw[i][j];
}
// backup
if(iter%cfreq == 0)
backup();
}
gettimeofday(&end_tv, NULL);
printf("Elapsed time: %f sec\n",
(double)( (double)(end_tv.tv_sec - start_tv.tv_sec) + ( (double)(end_tv.tv_usec - start_tv.tv_usec)/1000000)) );
// gather data
if(my_rank==0) {
for (i=0; i<myN; i++) {
for(j=0; j<N; j++) {
u[i][j] = myu[i][j];
}
}
if(proc_num > 1) {
for (i=1; i<proc_num-1; i++)
MPI_Recv(u[i*(N/proc_num)], (N/proc_num)*N, MPI_DOUBLE, i, 0, MPI_COMM_WORLD, &status);
// special care for last one
if(N%proc_num==0)
MPI_Recv(u[i*(N/proc_num)], (N/proc_num)*N, MPI_DOUBLE, i, 0, MPI_COMM_WORLD, &status);
else{
MPI_Recv(u[i*(N/proc_num)], (N-(N/proc_num)*(proc_num-1))*N, MPI_DOUBLE, i, 0, MPI_COMM_WORLD, &status);
}
}
}
else {
if(N%proc_num==0)
MPI_Send(myu[1], (N/proc_num)*N, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD);
else{
if(my_rank != proc_num-1)
MPI_Send(myu[1], (myN-2)*N, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD);
else
MPI_Send(myu[1], (myN-1)*N, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD);
}
}
if(my_rank == 0) {
/* Print Solution */
fp = fopen("output.dat", "w");
for (i=0; i<N; i++) {
for (j=0; j<N; j++) {
fprintf(fp, "%6.2f ", u[i][j]);
}
fprintf(fp, "\n");
}
fclose(fp);
}
mclose();
bclose();
MPI_Finalize();
return 0;
}
int
main(int argc, char *argv[])
{
int mtype, size, c,
list = FALSE, limit = -1, deflt = -1;
int fd;
char *userlist = 0, *user, **users, *p;
short status;
struct user_priority *ppri_tbl, *ld_priority_file();
extern char *optarg;
extern int optind, opterr, optopt, errno;
setlocale(LC_ALL, "");
#if !defined(TEXT_DOMAIN)
#define TEXT_DOMAIN "SYS_TEST"
#endif
(void) textdomain(TEXT_DOMAIN);
if(argc == 1) {
usage:
(void) printf(gettext("usage: \n"));
(void) printf(gettext("(assign priority limit to users)\n"));
(void) printf(gettext("\tlpusers -q priority -u user-list\n"));
(void) printf(gettext(
"(assign default priority limit for balance of users)\n"));
(void) printf(gettext("\tlpusers -q priority\n"));
(void) printf(gettext("(put users back to default priority limit)\n"));
(void) printf(gettext("\tlpusers -u user-list\n"));
(void) printf(gettext("(assign default priority)\n"));
(void) printf(gettext("\tlpusers -d priority\n"));
(void) printf(gettext("(examine priority limits, defaults)\n"));
(void) printf(gettext("\tlpusers -l\n"));
exit(argc == 1);
}
opterr = 0; /* disable printing of errors by getopt */
while ((c = getopt(argc, argv, "ld:q:u:")) != -1)
switch(c) {
case 'l':
if (list)
LP_ERRMSG1(WARNING, E_LP_2MANY, 'l');
list = TRUE;
break;
case 'd':
if (deflt != -1)
LP_ERRMSG1(WARNING, E_LP_2MANY, 'd');
deflt = (int)strtol(optarg,&p,10);
if (*p || deflt<PRI_MIN || deflt>PRI_MAX) {
LP_ERRMSG1(ERROR, E_LP_BADPRI, optarg);
exit(1);
}
break;
case 'q':
if (limit != -1)
LP_ERRMSG1(WARNING, E_LP_2MANY, 'q');
limit = (int)strtol(optarg,&p,10);
if (*p || limit<PRI_MIN || limit>PRI_MAX) {
LP_ERRMSG1(ERROR, E_LP_BADPRI, optarg);
exit(1);
}
break;
case 'u':
if (userlist)
LP_ERRMSG1(WARNING, E_LP_2MANY, 'u');
userlist = optarg;
break;
case '?':
if (optopt == '?') goto usage;
(p = "-X")[1] = optopt;
if (strchr("ldqu", optopt))
LP_ERRMSG1(ERROR, E_LP_OPTARG, p);
else
LP_ERRMSG1(ERROR, E_LP_OPTION, p);
exit(1);
}
if (optind < argc) {
LP_ERRMSG1(ERROR, E_LP_EXTRA, argv[optind]);
exit(1);
}
if (((list || deflt != -1) && (limit != -1 || userlist))
|| (list && deflt != -1)) {
LP_ERRMSG(ERROR, E_LP_OPTCOMB);
/* invalid combination of options */
exit(1);
}
PRIORITY = Lp_Users;
/* load existing priorities from file */
if (!(ppri_tbl = ld_priority_file(PRIORITY))) {
switch (errno) {
case EBADF:
LP_ERRMSG1(ERROR, E_LPU_BADFORM, PRIORITY);
break;
default:
LP_ERRMSG2(ERROR, E_LPU_BADFILE, PRIORITY, errno);
}
exit(1);
}
if (list) {
print_tbl(ppri_tbl);
exit (0);
} else {
if (userlist) {
users = getlist(userlist, " \t", ",");
if (users)
while (user = *users++) {
if (del_user(ppri_tbl, user) && (limit == -1))
LP_ERRMSG1(WARNING, E_LPU_NOUSER, user);
if (limit != -1) {
if (add_user(ppri_tbl, user, limit))
LP_ERRMSG1(WARNING, E_LPU_BADU, user);
}
}
} else if (deflt != -1)
ppri_tbl->deflt = deflt;
else
ppri_tbl->deflt_limit = limit;
if ((fd = open_locked(PRIORITY, "w", LPU_MODE)) < 0) {
LP_ERRMSG1(ERROR, E_LP_ACCESS, PRIORITY);
exit(1);
}
output_tbl(fd, ppri_tbl);
close(fd);
}
if (mopen()) /* error on mopen == no spooler, exit quietly */
exit(0);
(void)putmessage (message, S_LOAD_USER_FILE);
if (msend(message))
goto Error;
if (mrecv(reply, sizeof(reply)) == -1)
goto Error;
mtype = getmessage(reply, R_LOAD_USER_FILE, &status);
if (mtype != R_LOAD_USER_FILE) {
LP_ERRMSG1 (ERROR, E_LP_BADREPLY, mtype);
goto NoError;
}
if (status == 0)
goto NoError;
Error: LP_ERRMSG (ERROR, E_LPU_NOLOAD);
NoError:(void)mclose ();
return (0);
}
