void make_floor(std::unique_ptr<PhysicsWorld>& world) { btTransform trans; trans.setIdentity(); trans.setOrigin(btVector3(0.0, -5.0, 0.0)); btScalar mass(0.0); btVector3 local_inertia(0, 0, 0); btStaticPlaneShape* shape = new btStaticPlaneShape(btVector3(0.0f, 1.0f, 0.0f), 0.0f); world->get_collision_shapes().push_back(shape); btDefaultMotionState* motion_state = new btDefaultMotionState(trans); shape->calculateLocalInertia(mass, local_inertia); btRigidBody::btRigidBodyConstructionInfo body_info(mass, motion_state, shape, local_inertia); btRigidBody* body = new btRigidBody(body_info); body->setRestitution(0); world->get_dynamics_world()->addRigidBody(body); }
int main(int argc, char *argv[]) { init_list_body_data(); int nbodies, x, y; Window win; // initialization for a window GC gc; // graphics context Display *display = NULL; unsigned int width = X_RESN, height = Y_RESN; /* window size */ clock_t start, end, elapsed; int rank; int size; MPI_Init (&argc, &argv); /* starts MPI */ MPI_Comm_rank(MPI_COMM_WORLD, &rank); /* get current process id */ MPI_Comm_size(MPI_COMM_WORLD, &size); /* get number of processes */ // I follow this topic // http://stackoverflow.com/questions/9864510/struct-serialization-in-c-and-transfer-over-mpi // alow MPI tranfer truct data type const int num_of_item = 8; int blocklengths[8] = {1, 1, 1, 1, 1, 1, 1, 1}; MPI_Datatype types[8] = {MPI_DOUBLE, MPI_DOUBLE, MPI_DOUBLE, MPI_DOUBLE, MPI_DOUBLE, MPI_DOUBLE, MPI_DOUBLE, MPI_INT}; MPI_Datatype mpi_body_type; MPI_Aint offsets[8]; offsets[0] = offsetof(body, position_x); offsets[1] = offsetof(body, position_y); offsets[2] = offsetof(body, velocity_x); offsets[3] = offsetof(body, velocity_y); offsets[4] = offsetof(body, force_x); offsets[5] = offsetof(body, force_y); offsets[6] = offsetof(body, mass); offsets[7] = offsetof(body, body_id); MPI_Type_create_struct(num_of_item, blocklengths, offsets, types, &mpi_body_type); MPI_Type_commit(&mpi_body_type); // // http://stackoverflow.com/questions/11246150/synchronizing-master-slave-model-with-mpi // for master/slave int j = 0; int i = 0; int k = 0; int num_of_move =100; int index = 0; int p; int steps = MAX_BODY / (size - 1); if (( MAX_BODY % (size - 1)) > 0) { steps++; } if(rank == 0) { display = x11setup(&win, &gc, width, height); // other setup code in the master } for (j = 0; j < num_of_move; j++) { //which number of moves process complte!? if(rank == 0) { printf("Processed %d of %d\n", j, num_of_move); } for (k = 0; k < MAX_BODY; k ++) { index = 0; for (i = 0; i < steps; i++ ) { if(rank == 0) { //master for(p = 1; p < size; p++){ body a = list_body[k]; body b = list_body[index]; if (index >= MAX_BODY -1) { b = list_body[MAX_BODY -1]; } // send 2 body to calculate force MPI_Send(&a, 1, mpi_body_type, p, 20, MPI_COMM_WORLD); MPI_Send(&b, 1, mpi_body_type, p, 20, MPI_COMM_WORLD); //recieve result body b_recv; MPI_Recv(&b_recv, 1, mpi_body_type, p, 21, MPI_COMM_WORLD, MPI_STATUS_IGNORE); //update to list list_body[k] = b_recv; index++; } } else { //workers //receive 2 body to calculate force body a; MPI_Recv(&a, 1, mpi_body_type, 0, 20, MPI_COMM_WORLD, MPI_STATUS_IGNORE); body b; MPI_Recv(&b, 1, mpi_body_type, 0, 20, MPI_COMM_WORLD, MPI_STATUS_IGNORE); // calculating.... update_body_force(&a, &b); update_body_velocity(&a); update_body_location(&a); // finish! send body a to master MPI_Send(&a, 1, mpi_body_type, 0, 21, MPI_COMM_WORLD); } } } if(rank == 0) { XClearWindow(display, win); for (i = 0; i < MAX_BODY; i++) { // draw the bodies on the display body b = list_body[i]; // this function will draw a circle inside a 3x3 box with the upper left // corner at (x,y). N.b. the last 2 arguments mean that it will fill from // 0 to 360 degrees - a full circle if (i == 0) { XFillArc(display, win, gc, b.position_x , b.position_y, 6, 6, 0, 23040); } XFillArc(display, win, gc, b.position_x , b.position_y, 3, 3, 0, 23040); // you campicould also use XDrawPoint(display, win, gc, x, y) to draw a single // pixel at (x,y) } XFlush(display); //reset force for (i = 0; i < MAX_BODY; i++) { body *b = & list_body[i]; b->force_x = 0; b->force_y = 0; } } usleep(100 * 1000); } // finaly, use rank=0 (master) to output result if (rank == 0) { i = 0; for (i = 0; i < MAX_BODY; i++) { body_info(list_body[i]); } } // main loop // int running = 1; // loop variable // start = clock(); // while(running) { // // checks to see if there have been any events, // // will exit the main loop if any key is pressed // if(rank==0) { // if(XPending(display)) { // XEvent ev; // XNextEvent(display, &ev); // switch(ev.type) { // case KeyPress: // running = 0; // break; // } // } // } // your code to calculate the forces on the bodies goes here // end = clock(); // elapsed = end - start; // // only update the display if > 1 millisecond has passed since the last update // if(elapsed / (CLOCKS_PER_SEC/1000) > 1 && rank==0) { // XClearWindow(display, win); // for (i = 0; i < MAX_BODY; i++) { // draw the bodies on the display // body b = list_body[i]; // // this function will draw a circle inside a 3x3 box with the upper left // // corner at (x,y). N.b. the last 2 arguments mean that it will fill from // // 0 to 360 degrees - a full circle // XFillArc(display, win, gc, b.position_x , b.position_y, 3, 3, 0, 23040); // // you campicould also use XDrawPoint(display, win, gc, x, y) to draw a single // // pixel at (x,y) // } // start = end; // XFlush(display); // } // } // if(rank==0 && display) { // XCloseDisplay(display); // close the display window // } MPI_Finalize(); return EXIT_SUCCESS; }
int Handle_Packet (char *buffer, int bytes_recieved) { IP_Header *ip; int from_mask[4], to_mask[4]; unsigned int body_offset, body_size; #ifdef DEBUG #ifdef UNIX addr.s_addr = IP_FROM(buffer); fprintf (stdout, "\n%s", inet_ntoa(addr)); if (test_address (from_mask, flags.from_ip_mask) == 0) { fprintf (stdout, " (Src OK)"); } else { fprintf (stdout, " (Src WRONG)"); } addr.s_addr = IP_TO(buffer); fprintf (stdout, "\n%s", inet_ntoa(addr)); if (test_address (to_mask, flags.to_ip_mask) == 0) { fprintf (stdout, " (Dest OK)"); } else { fprintf (stdout, " (Dest WRONG)"); } fprintf (stdout, "\nProtocol: %d", PROTOCOL(buffer)); #endif #endif /********************************************************/ /* Dumping ethernet headers ? */ /********************************************************/ if (flags.eth_hd == YES) { dump_eth_header(ETH_HEADER(buffer), flags.desc); } if (ETH_FORMAT(buffer) != ETHERNET_II) { return HANDLER_OK; } /********************************************************/ /* Dump *IP* stuff *ONLY* */ /********************************************************/ if (ETH_TYPE(buffer) == IP_ETH) { /********************************************************/ /* Set IP masks */ /********************************************************/ get_addr (IP_FROM(buffer), from_mask); get_addr (IP_TO(buffer), to_mask); /*******************************************************/ /* Checking IP address with mask */ /* Checking port numbers */ /* Checking protocol */ /* ... */ /*******************************************************/ if ( (test_address (from_mask, flags.from_ip_mask) == 0) && (test_address (to_mask, flags.to_ip_mask) == 0) && ( (flags.from_port_num == ALL_PORT) || (get_src_port_number(buffer) == flags.from_port_num) ) && ( (flags.to_port_num == ALL_PORT) || (get_dst_port_number(buffer) == flags.to_port_num) ) && ( ( (PROTOCOL(buffer) == UDP_PACKET) && (flags.proto_udp == YES) ) || ( (PROTOCOL(buffer) == TCP_PACKET) && (flags.proto_tcp == YES) ) || ( (PROTOCOL(buffer) == IGMP_PACKET) && (flags.proto_igmp == YES) ) ) /* end test on protocol */ ) /* end if condition statement */ { /******************************************************************/ /* Sanity check */ /******************************************************************/ ip = IP_HEADER(buffer); if ( ((ntohs(ip->ip_total_length)+ETH_HD_LEN) > bytes_recieved) && (flags.verbose == YES) ) { fprintf (stdout, "\nWARNING: received %d bytes", bytes_recieved); fprintf (stdout, "\n total packet size "); fprintf (stdout, "%d bytes", ntohs(ip->ip_total_length)+ETH_HD_LEN); fprintf (stdout, "\n\nThis may be a network error ... skipping"); fprintf (stdout, " the packet.\n"); fflush (stdout); return HANDLER_OK; } /******************************************************************/ /* Dump the IP header if requested */ /******************************************************************/ if (flags.ip_hd == YES) { dump_ip_header(ip, flags.desc); } /******************************************************************/ /* Dump the following headers if requested: */ /* - UDP */ /* - TCP */ /* */ /* In the case of UDP, it may be a RIP message. */ /******************************************************************/ if (PROTOCOL(buffer) == UDP_PACKET) { if (flags.udp_hd == YES) { dump_udp_header(UDP_HEADER(buffer), flags.desc); } switch (UDP_SRC_PORT(buffer)) { case SER_RIP: if (RIP_VERSION(buffer) == 1) { dump_rip1_header (buffer, flags.desc); } else { fprintf (stdout, "\nRIP version 2 !"); }; break; default:; } } if ((PROTOCOL(buffer) == TCP_PACKET) && (flags.tcp_hd == YES)) { dump_tcp_header(TCP_HEADER(buffer), flags.desc); } /********************************************************************/ /* Dump the packet bopy for the following protocols if requested: */ /* - TCP */ /* - UDP */ /* - IGMP */ /* */ /* Note that for IGMP the IGMP header is not separated from the bo- */ /* -dy. */ /********************************************************************/ if (flags.body_level != BD_NONE) { /* Get offset and size of the body */ body_info (buffer, &body_offset, &body_size); switch (flags.body_level) { case BD_HEXA : dump_hexa (buffer+body_offset, body_size); break; case BD_ASCII : dump_ascii (buffer+body_offset, body_size); break; case BD_MIX : dump (buffer+body_offset, body_size); break; default : { if (flags.verbose == YES) { fprintf (stderr, "\nUnknown dump_body option\n"); } else { fprintf (stderr, "\nInternal error\n"); } return HANDLER_ERR; } } /* end switch (dump_body) */ } /* end if for UDP/TCP/dump_body */ } return HANDLER_OK; } /* end if for *IP* stuff *ONLY* */ /*****************************************************/ /* So it is not an IP stuff */ /*****************************************************/ /******************************************************/ /* May be it is ARP ? */ /******************************************************/ if ((ETH_TYPE(buffer) == ARP_ETH) && (flags.proto_arp == YES)) { dump_ARP_header (ARP_HEADER(buffer), flags.desc); } return HANDLER_OK; }