void EQEmu::ProfanityManager::RedactMessage(std::string &message) { if (message.length() < REDACTION_LENGTH_MIN || message.length() >= 4096) return; std::string test_message(const_cast<const std::string&>(message)); std::transform(test_message.begin(), test_message.end(), test_message.begin(), [](unsigned char c) -> unsigned char { return tolower(c); }); for (const auto &iter : profanity_list) { // consider adding textlink checks if it becomes an issue size_t pos = 0; size_t start_pos = 0; while (pos != std::string::npos) { pos = test_message.find(iter, start_pos); if (pos == std::string::npos) continue; if ((pos + iter.length()) == test_message.length() || !isalpha(test_message.at(pos + iter.length()))) { if (pos == 0 || !isalpha(test_message.at(pos - 1))) message.replace(pos, iter.length(), iter.length(), REDACTION_CHARACTER); } start_pos = (pos + iter.length()); } } }
void EQEmu::ProfanityManager::RedactMessage(char *message) { if (!message) return; std::string test_message(message); // hard-coded max length based on channel message buffer size (4096 bytes).. // ..will need to change or remove if other sources are used for redaction if (test_message.length() < REDACTION_LENGTH_MIN || test_message.length() >= 4096) return; std::transform(test_message.begin(), test_message.end(), test_message.begin(), [](unsigned char c) -> unsigned char { return tolower(c); }); for (const auto &iter : profanity_list) { // consider adding textlink checks if it becomes an issue size_t pos = 0; size_t start_pos = 0; while (pos != std::string::npos) { pos = test_message.find(iter, start_pos); if (pos == std::string::npos) continue; if ((pos + iter.length()) == test_message.length() || !isalpha(test_message.at(pos + iter.length()))) { if (pos == 0 || !isalpha(test_message.at(pos - 1))) memset((message + pos), REDACTION_CHARACTER, iter.length()); } start_pos = (pos + iter.length()); } } }
int main (void) { test_message (); test_attribute (); test_vectors (); test_hash_creds (); return 0; }
int main() { sys::error_category const & cat = sys::system_category(); // message for( int i = -2; i < 1024; ++i ) { test_message( cat, i ); } test_message( cat, 5810 ); for( int i = 10000; i < 11032; ++i ) { test_message( cat, i ); } return boost::report_errors(); }
bool EQEmu::ProfanityManager::ContainsCensoredLanguage(const std::string &message) { if (message.length() < REDACTION_LENGTH_MIN || message.length() >= 4096) return false; std::string test_message(message); std::transform(test_message.begin(), test_message.end(), test_message.begin(), [](unsigned char c) -> unsigned char { return tolower(c); }); for (const auto &iter : profanity_list) { if (test_message.find(iter) != std::string::npos) return true; } return false; }
void binary_reader::bin_read_tests::generation_messages( std::string test_file_name ) { std::ofstream test_file( BINARY_DIR + test_file_name, std::ios::binary ); BOOST_CHECK ( test_file.is_open() ); std::string str; char c = '1'; for( uint32_t i = 1; i < 10; i++, c++) { str = "test_string"; str += c; test_message msg( i, i, str.c_str() ); msg.write( test_file ); } test_message( 10ul, 10ul, NULL ).write( test_file ); test_file.close(); }
static gboolean test_stream (GMimeStream *stream) { GMimeParser *parser; GMimeMessage *msg; gboolean rv; parser = NULL; msg = NULL; parser = g_mime_parser_new_with_stream (stream); if (!parser) { g_warning ("failed to create parser"); rv = FALSE; goto leave; } msg = g_mime_parser_construct_message (parser); if (!msg) { g_warning ("failed to construct message"); rv = FALSE; goto leave; } rv = test_message (msg); leave: if (parser) g_object_unref (parser); else g_object_unref (stream); if (msg) g_object_unref (msg); return rv; }
int main(void) { sd_rtnl *rtnl; sd_rtnl_message *m; sd_rtnl_message *r; const char *string_data; int if_loopback; uint16_t type; test_message(); test_match(); test_multiple(); test_route(); test_container(); assert_se(sd_rtnl_open(&rtnl, 0) >= 0); assert_se(rtnl); if_loopback = (int) if_nametoindex("lo"); assert_se(if_loopback > 0); test_async(if_loopback); test_pipe(if_loopback); test_event_loop(if_loopback); test_link_configure(rtnl, if_loopback); test_get_addresses(rtnl); test_message_link_bridge(rtnl); assert_se(sd_rtnl_message_new_link(rtnl, &m, RTM_GETLINK, if_loopback) >= 0); assert_se(m); assert_se(sd_rtnl_message_get_type(m, &type) >= 0); assert_se(type == RTM_GETLINK); assert_se(sd_rtnl_message_read_string(m, IFLA_IFNAME, &string_data) == -EPERM); assert_se(sd_rtnl_call(rtnl, m, 0, &r) == 1); assert_se(sd_rtnl_message_get_type(r, &type) >= 0); assert_se(type == RTM_NEWLINK); assert_se((r = sd_rtnl_message_unref(r)) == NULL); assert_se(sd_rtnl_call(rtnl, m, -1, &r) == -EPERM); assert_se((m = sd_rtnl_message_unref(m)) == NULL); assert_se((r = sd_rtnl_message_unref(r)) == NULL); test_link_get(rtnl, if_loopback); test_address_get(rtnl, if_loopback); assert_se(sd_rtnl_flush(rtnl) >= 0); assert_se((m = sd_rtnl_message_unref(m)) == NULL); assert_se((r = sd_rtnl_message_unref(r)) == NULL); assert_se((rtnl = sd_rtnl_unref(rtnl)) == NULL); return EXIT_SUCCESS; }
int main (void) { parser = NULL; int i, j, k; int request_count; int response_count; printf("sizeof(http_parser) = %d\n", sizeof(http_parser)); for (request_count = 0; requests[request_count].name; request_count++); for (response_count = 0; responses[response_count].name; response_count++); //// RESPONSES for (i = 0; i < response_count; i++) { test_message(&responses[i]); } for (i = 0; i < response_count; i++) { if (!responses[i].should_keep_alive) continue; for (j = 0; j < response_count; j++) { if (!responses[j].should_keep_alive) continue; for (k = 0; k < response_count; k++) { test_multiple3(&responses[i], &responses[j], &responses[k]); } } } printf("response scan 1/1 "); test_scan( &responses[TRAILING_SPACE_ON_CHUNKED_BODY] , &responses[NO_HEADERS_NO_BODY_404] , &responses[NO_REASON_PHRASE] ); puts("responses okay"); /// REQUESTS test_error("hello world"); test_error("GET / HTP/1.1\r\n\r\n"); const char *dumbfuck2 = "GET / HTTP/1.1\r\n" "X-SSL-Bullshit: -----BEGIN CERTIFICATE-----\r\n" "\tMIIFbTCCBFWgAwIBAgICH4cwDQYJKoZIhvcNAQEFBQAwcDELMAkGA1UEBhMCVUsx\r\n" "\tETAPBgNVBAoTCGVTY2llbmNlMRIwEAYDVQQLEwlBdXRob3JpdHkxCzAJBgNVBAMT\r\n" "\tAkNBMS0wKwYJKoZIhvcNAQkBFh5jYS1vcGVyYXRvckBncmlkLXN1cHBvcnQuYWMu\r\n" "\tdWswHhcNMDYwNzI3MTQxMzI4WhcNMDcwNzI3MTQxMzI4WjBbMQswCQYDVQQGEwJV\r\n" "\tSzERMA8GA1UEChMIZVNjaWVuY2UxEzARBgNVBAsTCk1hbmNoZXN0ZXIxCzAJBgNV\r\n" "\tBAcTmrsogriqMWLAk1DMRcwFQYDVQQDEw5taWNoYWVsIHBhcmQYJKoZIhvcNAQEB\r\n" "\tBQADggEPADCCAQoCggEBANPEQBgl1IaKdSS1TbhF3hEXSl72G9J+WC/1R64fAcEF\r\n" "\tW51rEyFYiIeZGx/BVzwXbeBoNUK41OK65sxGuflMo5gLflbwJtHBRIEKAfVVp3YR\r\n" "\tgW7cMA/s/XKgL1GEC7rQw8lIZT8RApukCGqOVHSi/F1SiFlPDxuDfmdiNzL31+sL\r\n" "\t0iwHDdNkGjy5pyBSB8Y79dsSJtCW/iaLB0/n8Sj7HgvvZJ7x0fr+RQjYOUUfrePP\r\n" "\tu2MSpFyf+9BbC/aXgaZuiCvSR+8Snv3xApQY+fULK/xY8h8Ua51iXoQ5jrgu2SqR\r\n" "\twgA7BUi3G8LFzMBl8FRCDYGUDy7M6QaHXx1ZWIPWNKsCAwEAAaOCAiQwggIgMAwG\r\n" "\tA1UdEwEB/wQCMAAwEQYJYIZIAYb4QgHTTPAQDAgWgMA4GA1UdDwEB/wQEAwID6DAs\r\n" "\tBglghkgBhvhCAQ0EHxYdVUsgZS1TY2llbmNlIFVzZXIgQ2VydGlmaWNhdGUwHQYD\r\n" "\tVR0OBBYEFDTt/sf9PeMaZDHkUIldrDYMNTBZMIGaBgNVHSMEgZIwgY+AFAI4qxGj\r\n" "\tloCLDdMVKwiljjDastqooXSkcjBwMQswCQYDVQQGEwJVSzERMA8GA1UEChMIZVNj\r\n" "\taWVuY2UxEjAQBgNVBAsTCUF1dGhvcml0eTELMAkGA1UEAxMCQ0ExLTArBgkqhkiG\r\n" "\t9w0BCQEWHmNhLW9wZXJhdG9yQGdyaWQtc3VwcG9ydC5hYy51a4IBADApBgNVHRIE\r\n" "\tIjAggR5jYS1vcGVyYXRvckBncmlkLXN1cHBvcnQuYWMudWswGQYDVR0gBBIwEDAO\r\n" "\tBgwrBgEEAdkvAQEBAQYwPQYJYIZIAYb4QgEEBDAWLmh0dHA6Ly9jYS5ncmlkLXN1\r\n" "\tcHBvcnQuYWMudmT4sopwqlBWsvcHViL2NybC9jYWNybC5jcmwwPQYJYIZIAYb4QgEDBDAWLmh0\r\n" "\tdHA6Ly9jYS5ncmlkLXN1cHBvcnQuYWMudWsvcHViL2NybC9jYWNybC5jcmwwPwYD\r\n" "\tVR0fBDgwNjA0oDKgMIYuaHR0cDovL2NhLmdyaWQt5hYy51ay9wdWIv\r\n" "\tY3JsL2NhY3JsLmNybDANBgkqhkiG9w0BAQUFAAOCAQEAS/U4iiooBENGW/Hwmmd3\r\n" "\tXCy6Zrt08YjKCzGNjorT98g8uGsqYjSxv/hmi0qlnlHs+k/3Iobc3LjS5AMYr5L8\r\n" "\tUO7OSkgFFlLHQyC9JzPfmLCAugvzEbyv4Olnsr8hbxF1MbKZoQxUZtMVu29wjfXk\r\n" "\thTeApBv7eaKCWpSp7MCbvgzm74izKhu3vlDk9w6qVrxePfGgpKPqfHiOoGhFnbTK\r\n" "\twTC6o2xq5y0qZ03JonF7OJspEd3I5zKY3E+ov7/ZhW6DqT8UFvsAdjvQbXyhV8Eu\r\n" "\tYhixw1aKEPzNjNowuIseVogKOLXxWI5vAi5HgXdS0/ES5gDGsABo4fqovUKlgop3\r\n" "\tRA==\r\n" "\t-----END CERTIFICATE-----\r\n" "\r\n"; test_error(dumbfuck2); #if 0 // NOTE(Wed Nov 18 11:57:27 CET 2009) this seems okay. we just read body // until EOF. // // no content-length // error if there is a body without content length const char *bad_get_no_headers_no_body = "GET /bad_get_no_headers_no_body/world HTTP/1.1\r\n" "Accept: */*\r\n" "\r\n" "HELLO"; test_error(bad_get_no_headers_no_body); #endif /* TODO sending junk and large headers gets rejected */ /* check to make sure our predefined requests are okay */ for (i = 0; requests[i].name; i++) { test_message(&requests[i]); } for (i = 0; i < request_count; i++) { if (!requests[i].should_keep_alive) continue; for (j = 0; j < request_count; j++) { if (!requests[j].should_keep_alive) continue; for (k = 0; k < request_count; k++) { test_multiple3(&requests[i], &requests[j], &requests[k]); } } } printf("request scan 1/3 "); test_scan( &requests[GET_NO_HEADERS_NO_BODY] , &requests[GET_ONE_HEADER_NO_BODY] , &requests[GET_NO_HEADERS_NO_BODY] ); printf("request scan 2/3 "); test_scan( &requests[POST_CHUNKED_ALL_YOUR_BASE] , &requests[POST_IDENTITY_BODY_WORLD] , &requests[GET_FUNKY_CONTENT_LENGTH] ); printf("request scan 3/3 "); test_scan( &requests[TWO_CHUNKS_MULT_ZERO_END] , &requests[CHUNKED_W_TRAILING_HEADERS] , &requests[CHUNKED_W_BULLSHIT_AFTER_LENGTH] ); puts("requests okay"); return 0; }
static void test_transaction(void) { _c_cleanup_(b1_peer_unrefp) B1Peer *src = NULL, *dst = NULL; _c_cleanup_(b1_node_freep) B1Node *node = NULL; _c_cleanup_(b1_handle_unrefp) B1Handle *handle = NULL; _c_cleanup_(b1_message_unrefp) B1Message *message = NULL; const char *payload = "WOOF"; struct iovec vec = { .iov_base = (void*)payload, .iov_len = strlen(payload) + 1, }; struct iovec *vec_out; size_t n_vec; int r, fd; r = b1_peer_new(&src); assert(r >= 0); r = b1_peer_new(&dst); assert(r >= 0); r = b1_node_new(dst, &node); assert(r >= 0); r = b1_handle_transfer(b1_node_get_handle(node), src, &handle); assert(r >= 0); r = b1_message_new(src, &message); assert(r >= 0); r = b1_message_set_payload(message, &vec, 1); assert(r >= 0); r = b1_message_set_handles(message, &handle, 1); assert(r >= 0); fd = eventfd(0, 0); assert(fd >= 0); r = b1_message_set_fds(message, &fd, 1); assert(r >= 0); assert(close(fd) >= 0); r = b1_message_send(message, &handle, 1); assert(r >= 0); message = b1_message_unref(message); assert(!message); handle = b1_handle_unref(handle); assert(!handle); r = b1_peer_recv(dst, &message); assert(r >= 0); assert(message); assert(b1_message_get_type(message) == BUS1_MSG_DATA); assert(b1_message_get_destination_node(message) == node); assert(b1_message_get_uid(message) == getuid()); assert(b1_message_get_gid(message) == getgid()); assert(b1_message_get_pid(message) == getpid()); assert(b1_message_get_tid(message) == c_syscall_gettid()); r = b1_message_get_payload(message, &vec_out, &n_vec); assert(r >= 0); assert(vec_out); assert(n_vec == 1); assert(vec_out->iov_len == strlen("WOOF") + 1); assert(strcmp(vec_out->iov_base, "WOOF") == 0); r = b1_message_get_handle(message, 0, &handle); assert(r >= 0); assert(handle == b1_node_get_handle(node)); handle = NULL; r = b1_message_get_fd(message, 0, &fd); assert(r >= 0); assert(fd >= 0); message = b1_message_unref(message); r = b1_peer_recv(dst, &message); assert(r >= 0); assert(message); assert(b1_message_get_type(message) == BUS1_MSG_NODE_RELEASE); assert(b1_message_get_destination_node(message) == node); assert(b1_message_get_uid(message) == (uid_t)-1); assert(b1_message_get_gid(message) == (gid_t)-1); assert(b1_message_get_pid(message) == 0); assert(b1_message_get_tid(message) == 0); message = b1_message_unref(message); r = b1_node_destroy(node); assert(r >= 0); r = b1_peer_recv(dst, &message); assert(r >= 0); assert(message); assert(b1_message_get_type(message) == BUS1_MSG_NODE_DESTROY); assert(b1_message_get_destination_node(message)); assert(b1_message_get_destination_node(message) == node); assert(b1_message_get_uid(message) == (uid_t)-1); assert(b1_message_get_gid(message) == (gid_t)-1); assert(b1_message_get_pid(message) == 0); assert(b1_message_get_tid(message) == 0); message = b1_message_unref(message); r = b1_peer_recv(dst, &message); assert(r == -EAGAIN); r = b1_peer_recv(src, &message); assert(r == -EAGAIN); } static void test_multicast(void) { _c_cleanup_(b1_peer_unrefp) B1Peer *src = NULL, *dst1 = NULL, *dst2 = NULL; _c_cleanup_(b1_node_freep) B1Node *node1 = NULL, *node2 = NULL; _c_cleanup_(b1_message_unrefp) B1Message *message = NULL; const char *payload = "WOOF"; struct iovec vec = { .iov_base = (void*)payload, .iov_len = strlen(payload) + 1, }; struct iovec *vec_out; size_t n_vec; B1Handle *handles[2], *handle; int r, fd; r = b1_peer_new(&src); assert(r >= 0); r = b1_peer_new(&dst1); assert(r >= 0); r = b1_peer_new(&dst2); assert(r >= 0); r = b1_node_new(dst1, &node1); assert(r >= 0); r = b1_node_new(dst2, &node2); assert(r >= 0); r = b1_handle_transfer(b1_node_get_handle(node1), src, &handles[0]); assert(r >= 0); r = b1_handle_transfer(b1_node_get_handle(node2), src, &handles[1]); assert(r >= 0); r = b1_message_new(src, &message); assert(r >= 0); r = b1_message_set_payload(message, &vec, 1); assert(r >= 0); r = b1_message_set_handles(message, handles, 2); assert(r >= 0); fd = eventfd(0, 0); assert(fd >= 0); r = b1_message_set_fds(message, &fd, 1); assert(r >= 0); assert(close(fd) >= 0); r = b1_message_send(message, handles, 2); assert(r >= 0); message = b1_message_unref(message); assert(!message); handles[0] = b1_handle_unref(handles[0]); assert(!handles[0]); handles[1] = b1_handle_unref(handles[1]); assert(!handles[1]); r = b1_peer_recv(dst1, &message); assert(r >= 0); assert(message); assert(b1_message_get_type(message) == BUS1_MSG_DATA); assert(b1_message_get_destination_node(message) == node1); assert(b1_message_get_uid(message) == getuid()); assert(b1_message_get_gid(message) == getgid()); assert(b1_message_get_pid(message) == getpid()); assert(b1_message_get_tid(message) == c_syscall_gettid()); r = b1_message_get_payload(message, &vec_out, &n_vec); assert(r >= 0); assert(vec_out); assert(n_vec == 1); assert(vec_out->iov_len == strlen("WOOF") + 1); assert(strcmp(vec_out->iov_base, "WOOF") == 0); r = b1_message_get_handle(message, 0, &handle); assert(r >= 0); assert(handle == b1_node_get_handle(node1)); r = b1_message_get_handle(message, 1, &handle); assert(r >= 0); assert(handle); assert(handle != b1_node_get_handle(node1)); r = b1_message_get_fd(message, 0, &fd); assert(r >= 0); assert(fd >= 0); message = b1_message_unref(message); r = b1_peer_recv(dst2, &message); assert(r >= 0); assert(message); assert(b1_message_get_type(message) == BUS1_MSG_DATA); assert(b1_message_get_destination_node(message) == node2); assert(b1_message_get_uid(message) == getuid()); assert(b1_message_get_gid(message) == getgid()); assert(b1_message_get_pid(message) == getpid()); assert(b1_message_get_tid(message) == c_syscall_gettid()); r = b1_message_get_payload(message, &vec_out, &n_vec); assert(r >= 0); assert(vec_out); assert(n_vec == 1); assert(vec_out->iov_len == strlen("WOOF") + 1); assert(strcmp(vec_out->iov_base, "WOOF") == 0); r = b1_message_get_handle(message, 0, &handle); assert(r >= 0); assert(handle); assert(handle != b1_node_get_handle(node2)); r = b1_message_get_handle(message, 1, &handle); assert(r >= 0); assert(handle); assert(handle == b1_node_get_handle(node2)); r = b1_message_get_fd(message, 0, &fd); assert(r >= 0); assert(fd >= 0); message = b1_message_unref(message); r = b1_peer_recv(dst1, &message); assert(r >= 0); assert(message); assert(b1_message_get_type(message) == BUS1_MSG_NODE_RELEASE); assert(b1_message_get_destination_node(message) == node1); assert(b1_message_get_uid(message) == (uid_t)-1); assert(b1_message_get_gid(message) == (gid_t)-1); assert(b1_message_get_pid(message) == 0); assert(b1_message_get_tid(message) == 0); message = b1_message_unref(message); r = b1_peer_recv(dst2, &message); assert(r >= 0); assert(message); assert(b1_message_get_type(message) == BUS1_MSG_NODE_RELEASE); assert(b1_message_get_destination_node(message) == node2); assert(b1_message_get_uid(message) == (uid_t)-1); assert(b1_message_get_gid(message) == (gid_t)-1); assert(b1_message_get_pid(message) == 0); assert(b1_message_get_tid(message) == 0); message = b1_message_unref(message); r = b1_node_destroy(node1); assert(r >= 0); r = b1_peer_recv(dst1, &message); assert(r >= 0); assert(message); assert(b1_message_get_type(message) == BUS1_MSG_NODE_DESTROY); assert(b1_message_get_destination_node(message) == node1); assert(b1_message_get_uid(message) == (uid_t)-1); assert(b1_message_get_gid(message) == (gid_t)-1); assert(b1_message_get_pid(message) == 0); assert(b1_message_get_tid(message) == 0); message = b1_message_unref(message); r = b1_node_destroy(node2); assert(r >= 0); r = b1_peer_recv(dst2, &message); assert(r >= 0); assert(message); assert(b1_message_get_type(message) == BUS1_MSG_NODE_DESTROY); assert(b1_message_get_destination_node(message) == node2); assert(b1_message_get_uid(message) == (uid_t)-1); assert(b1_message_get_gid(message) == (gid_t)-1); assert(b1_message_get_pid(message) == 0); assert(b1_message_get_tid(message) == 0); message = b1_message_unref(message); r = b1_peer_recv(dst1, &message); assert(r == -EAGAIN); r = b1_peer_recv(dst2, &message); assert(r == -EAGAIN); r = b1_peer_recv(src, &message); assert(r == -EAGAIN); } int main(int argc, char **argv) { if (access("/dev/bus1", F_OK) < 0 && errno == ENOENT) return 77; test_peer(); test_node(); test_handle(); test_message(); test_transaction(); test_multicast(); return 0; }
int main (int argc, char **argv) { int success = 1; int verbose = 0; /* 1: verbose, 0 (or nothing: not verbose) */ int clone = 0; /* 1: verbose, 0 (or nothing: not verbose) */ int binary = 0; FILE *torture_file; char *msg; int pos; int len; for (pos = 3; pos < argc; pos++) { if (0 == strncmp (argv[pos], "-v", 2)) verbose = 1; else if (0 == strncmp (argv[pos], "-c", 2)) clone = 1; else if (0 == strncmp (argv[pos], "-b", 2)) binary = 1; else usage (); } if (argc < 3) { usage (); } torture_file = fopen (argv[1], "r"); if (torture_file == NULL) { usage (); } /* initialize parser */ parser_init (); if (binary) { if (read_binary (&msg, &len, torture_file) < 0) return -1; } else { msg = read_text (atoi (argv[2]), torture_file); if (!msg) return -1; len = strlen (msg); } success = test_message (msg, len, verbose, clone); if (verbose) { fprintf (stdout, "test %s : ============================ \n", argv[2]); fwrite (msg, 1, len, stdout); if (0 == success) fprintf (stdout, "test %s : ============================ OK\n", argv[2]); else fprintf (stdout, "test %s : ============================ FAILED\n", argv[2]); } osip_free (msg); fclose (torture_file); #ifdef __linux if (success) exit (EXIT_FAILURE); else exit (EXIT_SUCCESS); #endif return success; }
/** Program start */ int main (int argc, char *argv[]) { /* MPI stuff */ int rank = 0; int np = 0; char hostname[MPI_MAX_PROCESSOR_NAME+1]; int namelen = 0; /* Output file */ const char* outfile = "async.dat"; FILE *fp = NULL; /* output file, only valid on rank 0 */ /* Message buffer */ int* msgbuf = NULL; const int msglen = (1 << 21); /* 2^21 words */ double t_delay = 0; /* Current delay (seconds) */ const double delay_step = 1e-4; /* Delay step */ const double max_delay = 100*delay_step; /* Maximum delay */ /* Start MPI */ #if defined(_OPENMP) int mpi_omp_support_level; MPI_Init_thread (&argc, &argv, MPI_THREAD_MULTIPLE, &mpi_omp_support_level); #else MPI_Init (&argc, &argv); #endif MPI_Comm_rank (MPI_COMM_WORLD, &rank); /* Get process id */ MPI_Comm_size (MPI_COMM_WORLD, &np); /* Get number of processes */ MPI_Get_processor_name (hostname, &namelen); /* Get hostname of node */ fprintf (stderr, "[%s:rank %d of %d] Hello, world!\n", hostname, rank, np); /* This benchmark must be run between only two processes */ assert (np == 2); if (rank == 0) { fprintf (stderr, "\n"); fprintf (stderr, "Experimental parameters:\n"); fprintf (stderr, " Delay step: %g seconds\n", delay_step); fprintf (stderr, " Maximum delay: %g seconds\n", max_delay); #if defined (_OPENMP) fprintf (stderr, " OpenMP enabled; support level: "); switch (mpi_omp_support_level) { case MPI_THREAD_SINGLE: fprintf (stderr, "MPI_THREAD_SINGLE"); break; case MPI_THREAD_FUNNELED: fprintf (stderr, "MPI_THREAD_FUNNELED"); break; case MPI_THREAD_SERIALIZED: fprintf (stderr, "MPI_THREAD_SERIALIZED"); break; case MPI_THREAD_MULTIPLE: fprintf (stderr, "MPI_THREAD_MULTIPLE"); break; default: fprintf (stderr, "(unknown)"); } fprintf (stderr, "\n"); #else fprintf (stderr, " OpenMP disabled.\n"); #endif fprintf (stderr, " Output file: %s\n", outfile); fprintf (stderr, "\n"); } /* Open a file for writing results */ fprintf (stderr, "[%s:rank %d of %d] Opening output file, %s...\n", hostname, rank, np, outfile); if (rank == 0) { fp = fopen (outfile, "w"); assert (fp != NULL); } /* Create a message buffer */ fprintf (stderr, "[%s:rank %d of %d] Creating message buffer of size %d ints (%d bytes)...\n", hostname, rank, np, msglen, msglen * sizeof (int)); msgbuf = (int *)malloc (msglen * sizeof (int)); assert (msgbuf); /* Runs the asynchronous test-delay protocol */ while (t_delay < max_delay) { double t_elapsed = -1; init_message (rank, msgbuf, msglen); /* reset the message */ test_message (rank, msgbuf, msglen); /* redundant check */ MPI_Barrier (MPI_COMM_WORLD); #pragma omp parallel #pragma omp single nowait t_elapsed = async_comm_test (t_delay, rank, msgbuf, msglen); /* Check that the msgbufs match initial values on rank 0 */ test_message (0, msgbuf, msglen); /* Write out the timing result */ if (rank == 0) { printf ("%g\t%g\n", t_delay, t_elapsed); fflush (stdout); fprintf (fp, "%g\t%g\n", t_delay, t_elapsed); fflush (fp); } t_delay += delay_step; } while (t_delay <= max_delay); fprintf (stderr, "[%s:rank %d of %d] Done! Cleaning up...\n", hostname, rank, np); free (msgbuf); if (rank == 0) { fclose (fp); /* Close output file */ } fprintf (stderr, "[%s:rank %d of %d] Shutting down MPI...\n", hostname, rank, np); MPI_Finalize (); fprintf (stderr, "[%s:rank %d of %d] Bye bye.\n", hostname, rank, np); return 0; }