int main(int argc, const char *argv[]) {
int count = 1024*1024;
float *data1 = (float *)malloc(sizeof(float)*count); // original data set given to device
float *data2 = (float *)malloc(sizeof(float)*count); // original data set given to device
float *results = (float *)malloc(sizeof(float)*count); // original data set given to device
int correct; // number of correct results returned
int i = 0;
for(i = 0; i < count; i++) {
//data1[i] = rand() / (float)RAND_MAX;
//data2[i] = rand() / (float)RAND_MAX;
data1[i] = 1.1;
data2[i] = 3.2;
}
call_kernel(data1,data2,count,"./simple_add.cl",results);
correct = 0;
for(i = 0; i < count; i++) {
if(results[i] == sin(data1[i]+data2[i]))
correct++;
//printf("%f-----%f\n",results[i],data1[i]+data2[i]);
}
printf("'%d/%d' correct values!\n", correct, count);
free(data1);
free(data2);
free(results);
return 0;
}
void
init_arrays(double target_time)
{
if (DEBUG) fprintf(stderr, "called init_arrays with target_time = %f \n",
(target_time * 1e6));
#ifdef _ENABLE_CUDA_KERNEL_
if (options.target == gpu || options.target == both) {
/* Setting size of arrays for Dummy Compute */
int N = options.device_array_size;
/* Device Arrays for Dummy Compute */
allocate_device_arrays(N);
double time_elapsed = 0.0;
double t1 = 0.0, t2 = 0.0;
while (1) {
t1 = MPI_Wtime();
if (options.target == gpu || options.target == both) {
cudaStreamCreate(&stream);
call_kernel(A, d_x, d_y, N, &stream);
cudaDeviceSynchronize();
cudaStreamDestroy(stream);
}
t2 = MPI_Wtime();
if ((t2-t1) < target_time)
{
N += 32;
/* Now allocate arrays of size N */
allocate_device_arrays(N);
}
else {
break;
}
}
/* we reach here with desired N so save it and pass it to options */
options.device_array_size = N;
if (DEBUG) fprintf(stderr, "correct N = %d\n", N);
}
#endif
}
int main(int argc, const char *argv[]) {
float xlc0 = 0.0;
float ylc0 = 0.0;
float ql0 = 0.7;
float rc0 = 0.1;
float re0 = 1.0;
float phi0 = 0.0;
float lpar[] = {ylc0,xlc0,ql0,rc0,re0,phi0};
int count = 1024*1024;
float *xi1 = (float *)malloc(sizeof(float)*count);
float *xi2 = (float *)malloc(sizeof(float)*count);
float *alpha1 = (float *)malloc(sizeof(float)*count);
float *alpha2 = (float *)malloc(sizeof(float)*count);
int correct;
int i = 0;
for(i = 0; i < count; i++) {
xi1[i] = rand() / (float)RAND_MAX;
xi2[i] = rand() / (float)RAND_MAX;
}
call_kernel(xi1,xi2,count,lpar,alpha1,alpha2,"./play_with.cl");
float *alpha1_c = (float *)malloc(sizeof(float)*count);
float *alpha2_c = (float *)malloc(sizeof(float)*count);
correct = 0;
for(i = 0; i < count; i++) {
lq_nie(xi1[i],xi2[i],lpar,&alpha1_c[i],&alpha2_c[i]);
printf("%f-----%f||%f-----%f\n",alpha1[i],alpha1_c[i],alpha2[i],alpha2_c[i]);
}
free(xi1);
free(xi2);
free(alpha1);
free(alpha2);
free(alpha1_c);
free(alpha2_c);
return 0;
}
void
do_compute_gpu(double seconds)
{
int i,j;
double time_elapsed = 0.0, t1 = 0.0, t2 = 0.0;
{
t1 = MPI_Wtime();
/* Execute Dummy Kernel on GPU if set by user */
if (options.target == both || options.target == gpu) {
{
cudaStreamCreate(&stream);
call_kernel(A, d_x, d_y, options.device_array_size, &stream);
}
}
t2 = MPI_Wtime();
time_elapsed += (t2-t1);
}
}
void
init_arrays(double target_time)
{
if (DEBUG) fprintf(stderr, "called init_arrays with target_time = %f \n", (target_time * 1e6));
int i = 0, j = 0;
a = (float **)malloc(DIM * sizeof(float *));
for (i = 0; i < DIM; i++) {
a[i] = (float *)malloc(DIM * sizeof(float));
}
x = (float *)malloc(DIM * sizeof(float));
y = (float *)malloc(DIM * sizeof(float));
for (i = 0; i < DIM; i++) {
x[i] = y[i] = 1.0f;
for (j = 0; j < DIM; j++) {
a[i][j] = 2.0f;
}
}
#ifdef _ENABLE_CUDA_KERNEL_
if (options.target == gpu || options.target == both) {
/* Setting size of arrays for Dummy Compute */
int N = options.device_array_size;
/* Device Arrays for Dummy Compute */
allocate_device_arrays(N);
double time_elapsed = 0.0;
double t1 = 0.0, t2 = 0.0;
while (1) {
t1 = MPI_Wtime();
if (options.target == gpu || options.target == both) {
cudaStreamCreate(&stream);
call_kernel(A, d_x, d_y, N, &stream);
cudaDeviceSynchronize();
cudaStreamDestroy(stream);
}
t2 = MPI_Wtime();
if ((t2-t1) < target_time)
{
N += 32;
/* First free the old arrays */
free_device_arrays();
/* Now allocate arrays of size N */
allocate_device_arrays(N);
}
else {
break;
}
}
/* we reach here with desired N so save it and pass it to options */
options.device_array_size = N;
if (DEBUG) fprintf(stderr, "correct N = %d\n", N);
}
#endif
}
EFI_STATUS efi_main(EFI_HANDLE ImageHandle, EFI_SYSTEM_TABLE *SystemTable)
{
InitializeLib(ImageHandle, SystemTable);
CallConstructors();
EFI_STATUS Status;
const char16_t* searchdir = u"\\EFI\\ChaiOS\\";
if (Status = SetWorkingDirectory(searchdir))
printf(u"Error setting working directory: %s\r\n", getError(Status));
CHAIOS_BOOT_FILES* bootfile = nullptr;
while (bootfile = iterateBootFiles(bootfile))
{
if (bootfile->loadLocation != nullptr)
continue; //Support in-memory images
EFI_FILE* file = OpenFile(bootfile->fileName, "r");
if (!file)
{
printf(u"Error: could not open %s: %s\r\n", bootfile->fileName, getError(getErrno()));
}
UINT64 fileSize = GetFileSize(file);
VOID* bootfilebuf = kmalloc(fileSize+1);
UINTN read = ReadFile(bootfilebuf, 1, fileSize, file);
if (read < fileSize)
printf(u"Read %d bytes, failed\r\n", read);
else
printf(u"Successfully read %d bytes\r\n", read);
//Boot file is now loaded into memory
CloseFile(file);
bootfile->loadLocation = bootfilebuf;
bootfile->fileSize = fileSize;
if (bootfile->bootType == CHAIOS_BOOT_CONFIGURATION)
{
//We need to parse this now. INI format
((char*)bootfilebuf)[fileSize] = '\0';
ini_parse_string((const char*)bootfilebuf, &bootini_handler, nullptr);
}
}
//size_t value = GetIntegerInput(u"Enter scrolling lines configuration: ");
//set_scrolllines(value);
UINT32 AutoMode = IterateGraphicsMode(&match_config_resoultion);
EFI_GRAPHICS_OUTPUT_MODE_INFORMATION* info; UINTN SizeOfInfo;
if (AutoMode == UINT32_MAX)
{
if (!EFI_ERROR(GetGraphicsModeInfo(AutoMode, &info, &SizeOfInfo)))
{
IterateGraphicsMode(&print_graphics_mode);
size_t value = GetIntegerInput(u"Enter boot graphics mode: ");
SetGraphicsMode(value);
AutoMode = value;
}
}
else
{
SetGraphicsMode(AutoMode);
}
if (!EFI_ERROR(GetGraphicsModeInfo(AutoMode, &info, &SizeOfInfo)))
{
printf(u"Graphics mode %d: %dx%d\r\n", AutoMode, info->HorizontalResolution, info->VerticalResolution);
}
puts(u"ChaiOS 0.09 UEFI Loader\r\n");
int majorver = SystemTable->Hdr.Revision / (1 << 16);
int minorver = SystemTable->Hdr.Revision % (1 << 16);
printf(u"Firmware Vendor: %s, version: %d (UEFI:%d.%d)\r\n", SystemTable->FirmwareVendor, SystemTable->FirmwareRevision, majorver, minorver);
//Read ACPI configuration tables
//startup_acpi(SystemTable);
//startup_multiprocessor();
const size_t EARLY_PAGE_STACK_SIZE = 1024*1024;
EFI_PHYSICAL_ADDRESS earlyPhypageStack = 0;
if (EFI_ERROR(SystemTable->BootServices->AllocatePages(AllocateAnyPages, EfiLoaderData, EARLY_PAGE_STACK_SIZE / EFI_PAGE_SIZE, &earlyPhypageStack)))
{
puts(u"Could not allocate page stack\r\n");
return EFI_OUT_OF_RESOURCES;
}
SystemTable->BootServices->SetWatchdogTimer(0, 0, 0, nullptr);
PrepareExitBootServices();
EfiMemoryMap map;
map.MemMapSize = map.MapKey = map.DescriptorSize = map.DescriptorVersion = 0;
SystemTable->BootServices->GetMemoryMap(&map.MemMapSize, nullptr, &map.MapKey, &map.DescriptorSize, &map.DescriptorVersion);
//Give a nice bit of room to spare (memory map can change)
map.MemMapSize += 16 * map.DescriptorSize;
map.memmap = (EFI_MEMORY_DESCRIPTOR*)kmalloc(map.MemMapSize); //Allocate a nice buffer
SystemTable->BootServices->GetMemoryMap(&map.MemMapSize, map.memmap, &map.MapKey, &map.DescriptorSize, &map.DescriptorVersion);
printf(u"EFI Memory Map: Descriptor size %d\n", map.DescriptorSize);
#if 0
//Dump the UEFI memory map to a file for testing
EFI_FILE* file = OpenFile(u"efimap.dat", "w");
if (!file)
{
printf(u"Error: could not open %s: %s\r\n", u"efimap.dat", getError(getErrno()));
}
WriteFile(map.memmap, 1, map.MemMapSize, file);
CloseFile(file);
#endif
if (EFI_ERROR(Status = SystemTable->BootServices->ExitBootServices(ImageHandle, map.MapKey)))
{
printf(u"Failed to exit boot services: %s\r\n", getError(Status));
UINTN index;
SystemTable->BootServices->WaitForEvent(1, &SystemTable->ConIn->WaitForKey, &index);
return EFI_SUCCESS;
}
//We need to take control of the hardware now. Setup basic memory management
setLiballocAllocator(nullptr, nullptr);
InitializePmmngr(map, (void*)earlyPhypageStack, EARLY_PAGE_STACK_SIZE);
puts(u"Physical memory manager intialized\n");
arch_initialize_paging();
puts(u"Paging initialized\n");
setLiballocAllocator(&arch_allocate_pages, &arch_free_pages);
//Now load the OS!
bootfile = nullptr;
kimage_entry kentry = nullptr;
KLOAD_HANDLE kernel = NULL;
while (bootfile = iterateBootFiles(bootfile))
{
printf(u"Boot file: %s @ %x, length %d, type %d\n", bootfile->fileName, bootfile->loadLocation, bootfile->fileSize, bootfile->bootType);
if (!bootfile->loadLocation)
continue;
if (bootfile->bootType == CHAIOS_DLL)
{
KLOAD_HANDLE dll = LoadImage(bootfile->loadLocation, bootfile->fileName);
if (GetProcAddress(dll, "memcpy"))
{
set_memcpy((memcpy_proc)GetProcAddress(dll, "memcpy"));
}
}
else if (bootfile->bootType == CHAIOS_KERNEL)
{
kernel = LoadImage(bootfile->loadLocation, bootfile->fileName);
kentry = GetEntryPoint(kernel);
}
}
size_t kstacksize = GetStackSize(kernel);
if (!paging_map(stackaddr, PADDR_T_MAX, kstacksize, PAGE_ATTRIBUTE_WRITABLE))
{
puts(u"Error: could not allocate kernel stack\n");
while (1);
}
KERNEL_BOOT_INFO bootinfo;
fill_pmmngr_info(bootinfo.pmmngr_info);
fill_arch_paging_info(bootinfo.paging_info);
fill_modloader_info(bootinfo.modloader_info);
get_framebuffer_info(bootinfo.fbinfo);
populate_kterm_info(bootinfo.kterm_status);
bootinfo.efi_system_table = SystemTable;
bootinfo.memory_map = ↦
bootinfo.loaded_files = &bootfiles;
bootinfo.boottype = CHAIOS_BOOT_TYPE_UEFI;
bootinfo.printf_proc = &printf;
bootinfo.puts_proc = &puts;
printf(u"Success: Kernel entry point at %x, stack at %x, length %x\n", kentry, stackaddr, kstacksize);
call_kernel(&bootinfo, kentry, stackaddr, kstacksize);
puts(u"Kernel returned");
while (1);
}
