/**
* host function.
* This function calls corresponding kernel function.
*
* @param[in] d_status kernel I/O data.
* @param[in] num_data number of data to be generated.
*/
void make_single_random(cl_mem d_status,
cl_mem d_params,
int num_data,
int block_num) {
cl_mem d_data;
float* h_data;
cl_int clerr;
cl_event ev;
size_t global_work_size;
size_t local_work_size;
int size;
struct timeval t1, t2;
printf("generating single precision floating point random numbers.\n");
d_data = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(cl_float) * num_data, NULL, &clerr); CLERR;
// ccudaMalloc((void**)&d_data, sizeof(uint32_t) * num_data);
h_data = (float*) malloc(sizeof(float) * num_data);
if (h_data == NULL) {
printf("failure in allocating host memory for output data.\n");
exit(1);
}
gettimeofday(&t1, NULL);
global_work_size = THREAD_NUM * block_num;
local_work_size = THREAD_NUM;
size = num_data / block_num;
clerr = clSetKernelArg(mtgp32_single_kernel, 0, sizeof(cl_mem), &d_status); CLERR;
clerr = clSetKernelArg(mtgp32_single_kernel, 1, sizeof(cl_mem), &d_data); CLERR;
clerr = clSetKernelArg(mtgp32_single_kernel, 2, sizeof(cl_uint) * LARGE_SIZE, NULL); CLERR;
clerr = clSetKernelArg(mtgp32_single_kernel, 3, sizeof(cl_mem), &d_params); CLERR;
clerr = clSetKernelArg(mtgp32_single_kernel, 4, sizeof(cl_int), &size); CLERR;
clerr = clEnqueueNDRangeKernel(commands, mtgp32_single_kernel, 1, NULL, &global_work_size, &local_work_size, 0, NULL, &ev); CLERR;
clerr = clWaitForEvents(1, &ev); CLERR;
gettimeofday(&t2, NULL);
/* kernel call */
// mtgp32_uint32_kernel<<< block_num, THREAD_NUM>>>(
// d_status, d_data, num_data / block_num);
// cudaThreadSynchronize();
clerr = clEnqueueReadBuffer(commands, d_data, CL_TRUE, 0, sizeof(cl_float) * num_data, h_data, 0, NULL, NULL); CLERR;
// ccudaMemcpy(h_data, d_data, sizeof(uint32_t) * num_data, cudaMemcpyDeviceToHost);
print_float_array(h_data, num_data, block_num);
printf("generated numbers: %d\n", num_data);
printf("Processing time: %lu (ms)\n", time_diff(t2, t1));
printf("Samples per second: %E \n", num_data / (time_diff(t2, t1) * 0.000001));
//free memories
free(h_data);
clerr = clReleaseMemObject(d_data); CLERR;
}
int main() {
const int ARRAY_SIZE = 4;
int int_array[ARRAY_SIZE] = {5, 111, -86, 84};
qsort(int_array, ARRAY_SIZE, sizeof(int), compare_func);
print_int_array(int_array, ARRAY_SIZE);
char char_array[ARRAY_SIZE] = {'z', 'y', 'c', 't'};
qsort(char_array, ARRAY_SIZE, sizeof(char), compare_char);
print_char_array(char_array, ARRAY_SIZE);
float float_array[ARRAY_SIZE] = {1.2, 99.6, 3.14, 0.4751};
qsort(float_array, ARRAY_SIZE, sizeof(float), compare_float);
print_float_array(float_array, ARRAY_SIZE);
return 0;
}
void typeArrayKlass::oop_print_on(oop obj, outputStream* st) {
arrayKlass::oop_print_on(obj, st);
typeArrayOop ta = typeArrayOop(obj);
int print_len = MIN2((intx) ta->length(), MaxElementPrintSize);
switch (element_type()) {
case T_BOOLEAN: print_boolean_array(ta, print_len, st); break;
case T_CHAR: print_char_array(ta, print_len, st); break;
case T_FLOAT: print_float_array(ta, print_len, st); break;
case T_DOUBLE: print_double_array(ta, print_len, st); break;
case T_BYTE: print_byte_array(ta, print_len, st); break;
case T_SHORT: print_short_array(ta, print_len, st); break;
case T_INT: print_int_array(ta, print_len, st); break;
case T_LONG: print_long_array(ta, print_len, st); break;
default: ShouldNotReachHere();
}
int remaining = ta->length() - print_len;
if (remaining > 0) {
tty->print_cr(" - <%d more elements, increase MaxElementPrintSize to print>", remaining);
}
}
int main(int argc, char *argv[])
{
int len = 5;
// seed the random number generator
srand(time(NULL));
int* arrayA = rand_array(len);
print_int_array(arrayA, len);
int* arrayB = rand_array(len);
print_int_array(arrayB, len);
complex_number* complexArray = initialize_complex_array(arrayA, arrayB, len);
float* magnitudeArray = calculate_magnitudes(complexArray, len);
print_float_array(magnitudeArray, len);
// free memory
free(arrayA);
free(arrayB);
free(complexArray);
free(magnitudeArray);
}
int main(int argc, char *argv[])
{
struct sockaddr_in fsin;
int msock;
fd_set wfds;
fd_set rfds;
fd_set afds;
int alen;
int ctrlsockfds[MAX_CTRL];
int fd, nfds, rc, a, i, ctrlnum = 0, uti_count = 0;
int isnt_bal = 0, GA_running_lock = 0, init_stat = 1, sw_info_ctr = 0 ;
float array_uti[100];
for( i = 0 ; i < 100 ; i++ )
array_uti[i] = 0;
char *temp = malloc(sizeof(char)*1000);
char *line, *rmnline;
int debugflag = 0;
if( argv[1] == NULL )
{
printf("./<file> <port>");
exit(-1);
}
msock = tcp(argv[1]);
nfds = getdtablesize();
FD_ZERO( &afds );
FD_SET( msock, &afds );
while(1)
{
memcpy(&rfds, &afds, sizeof(rfds));
memcpy(&wfds, &afds, sizeof(wfds));
if(select(nfds, &rfds, &wfds, (fd_set *)0, (struct timeval*)0) < 0)
{
fprintf(stderr, "select: %s.\n", strerror(errno));
exit(EXIT_FAILURE);
}
if(FD_ISSET(msock, &rfds))
{
int ssock;
alen = sizeof(fsin);
ssock = accept(msock, (struct sockaddr *)&fsin, &alen);
if(ssock < 0)
{
fprintf(stderr,"accept: %s.\n", strerror(errno));
exit(EXIT_FAILURE);
}
fprintf(stdout, "\nClient conneted, fd=%d.\n",ssock);
FD_SET(ssock, &afds); //** set FD_SET **//
printf("%d\n", ssock);
//add_ctrl_fd( ctrlsockfds, getctrlindex( ctrlsockfds ), ssock);
ctrlnum ++; //** linked controller number +1 **//
/** communication **/
char *sucMsg = "\nServer: Server connected sucess.\n\0";
write( ssock, sucMsg, strlen(sucMsg) );
continue;
}
for(fd = 0; fd < nfds; ++fd)
{
if(fd != msock && FD_ISSET(fd, &rfds))
{
//printf("debugflag=%d\n", debugflag);
line = rcv_cli_msg( fd, temp );
rmnline = rm_ln_from_line( line );
if(strstr( line, "disconnect") != NULL)
{
printf("%s\n", rmnline);
(void) close(fd);
FD_CLR(fd, &afds);
//rm_ctrl_fd( ctrlsockfds, fd );
ctrlnum--;
bzero(temp, 999);
}
else
{
//printf("%s\n", rmnline);
debugflag++;
char *cindex, *uti;
//** record CPU utl **//
if( ctrlnum >= 3 )
{
cindex = strtok( rmnline, " " );
uti = strtok( NULL, " " );
printf( "%s ", cindex );
if( strcmp(uti, "inf" ) != 0 )
{
//printf("%f\n", atof(uti) );
if( uti_count >= 15 && init_stat == 1 )
init_stat = 0;
if( uti_count >= 15 ) //** record 2.5 sec uti a set **//
{
uti_count = 0;
}
array_uti[uti_count] = atof(uti);
uti_count ++;
print_float_array(array_uti, 15);
print_array_avg(array_uti, 15);
if( average(array_uti, 15) >= SCALOUTCPU )
{
exec_scal_out();
sleep(5);
}
if( (average(array_uti, 15) <= SCALINCPU) && (ctrlnum > 3) && (init_stat == 0) )
{
exec_scal_in();
sleep(5);
}
if( init_stat == 0 ) // array isn't in initial state, start count balanced
isnt_bal = not_balance(array_uti, 15);
if( isnt_bal == 1 && GA_running_lock == 0 )
printf("Not balanced!\n");
if( isnt_bal == 1 && GA_running_lock == 0 )
{
printf("start GA!\n");
GA_running_lock = 1;
exec_GA( ctrlnum );
sleep(5);
GA_running_lock = 2;
isnt_bal = 0;
}
else ;
}
else
{
printf("dont get\n");
}
}
//** end of record CPU utl **//
bzero(temp, 999);
}
}
if(fd != msock && FD_ISSET(fd, &wfds))
{
;
}
}
}
}
