void RunFeaturesLoadingBenchmark(string const & file, pair<int, int> scaleRange, AllResult & res)
{
string fileName = file;
base::GetNameFromFullPath(fileName);
base::GetNameWithoutExt(fileName);
platform::LocalCountryFile localFile =
platform::LocalCountryFile::MakeForTesting(fileName);
model::FeaturesFetcher src;
auto const r = src.RegisterMap(localFile);
if (r.second != MwmSet::RegResult::Success)
return;
uint8_t const minScale = r.first.GetInfo()->m_minScale;
uint8_t const maxScale = r.first.GetInfo()->m_maxScale;
if (minScale > scaleRange.first)
scaleRange.first = minScale;
if (maxScale < scaleRange.second)
scaleRange.second = maxScale;
if (scaleRange.first > scaleRange.second)
return;
RunBenchmark(src, r.first.GetInfo()->m_bordersRect, scaleRange, res);
}
int main(int argc, char **argv)
{
OptionParser op;
op.addOption("verbose", OPT_BOOL, "", "enable verbose output", 'v');
op.addOption("passes", OPT_INT, "10", "specify number of passes", 'n');
op.addOption("size", OPT_INT, "1", "specify problem size", 's');
op.addOption("target", OPT_INT, "0", "specify MIC target device number", 't');
// If benchmark has any specific options, add those
addBenchmarkSpecOptions(op);
if (!op.parse(argc, argv))
{
op.usage();
return -1;
}
ResultDatabase resultDB;
// Run the test
RunBenchmark(op, resultDB);
// Print out results to stdout
resultDB.DumpDetailed(cout);
return 0;
}
void xrSASH::LoopOA()
{
oaCommand Command;
bool bExit = false;
while (!bExit)
{
// It must be called on the oaCommand object sent to
// oaGetNextCommand() before each call to oaGetNextCommand().
oaInitCommand(&Command);
switch(oaGetNextCommand(&Command))
{
/* No more commands, exit program */
case OA_CMD_EXIT:
Msg("SASH:: Exit.");
bExit = true;
break;
/* Run as normal */
case OA_CMD_RUN:
//RunApp();
//Msg("SASH:: GetCurrentOptions.");
bExit = true;
break;
/* Enumerate all in-game options */
case OA_CMD_GET_ALL_OPTIONS:
GetAllOptions();
break;
/* Return the option values currently set */
case OA_CMD_GET_CURRENT_OPTIONS:
GetCurrentOptions();
break;
/* Set all in-game options */
case OA_CMD_SET_OPTIONS:
SetOptions();
break;
/* Enumerate all known benchmarks */
case OA_CMD_GET_BENCHMARKS:
GetBenchmarks();
break;
/* Run benchmark */
case OA_CMD_RUN_BENCHMARK:
RunBenchmark(Command.BenchmarkName);
break;
}
}
}
//------------------------------------------------------------------------------
BenchmarkReport Run() noexcept
{
auto benchmarks = BenchmarkRegistry::Get().GetBenchmarks();
std::unordered_map<std::string, std::vector<BenchmarkReport::Benchmark>> benchmarkResults;
for (const auto& benchmark : benchmarks)
{
benchmarkResults[benchmark.GetBenchmarkGroupName()].push_back(RunBenchmark(benchmark));
}
return GenerateReport(benchmarkResults);
}
/*--------------------------------------
* Function: main()
* Parameters:
*
* Description:
* Programmets huvudfunktion.
*------------------------------------*/
main() {
PrintIntroMessage();
printf("Number of points to use? ");
int numPoints = GetIntFromUser();
if (numPoints < 1 ) numPoints = 1;
if (numPoints > MaxPoints) numPoints = MaxPoints;
printf("Do you want to run the benchmark? (y/N) ");
bool benchmark = GetBoolFromUser(FALSE);
printf("\n");
#ifndef _DEBUG
// Vi slumpar inte "på riktigt" i debugläge.
srand((unsigned int)time(NULL));
#endif
if (benchmark) RunBenchmark(numPoints);
else RunSandbox (numPoints);
}
void xrSASH::LoopNative()
{
string_path in_file;
FS.update_path(in_file, "$app_data_root$", m_strBenchCfgName);
CInifile ini(in_file);
IReader* R = FS.r_open(in_file);
if (R)
{
FS.r_close(R);
int test_count = ini.line_count("benchmark");
LPCSTR test_name, t;
shared_str test_command;
for (int i = 0; i < test_count; ++i)
{
ini.r_line("benchmark", i, &test_name, &t);
//xr_strcpy(g_sBenchmarkName, test_name);
test_command = ini.r_string_wb("benchmark", test_name);
u32 cmdSize = test_command.size() + 1;
Core.Params = (char*)xr_realloc(Core.Params, cmdSize);
xr_strcpy(Core.Params, cmdSize, test_command.c_str());
xr_strlwr(Core.Params);
RunBenchmark(test_name);
// Output results
ReportNative(test_name);
}
}
else
Msg("oa:: Native path can't find \"%s\" config file.", in_file);
FlushLog();
}
// The `main program' equivalent, creating the windows and returning the
// main frame
bool AudacityApp::OnInit()
{
// Unused strings that we want to be translated, even though
// we're not using them yet...
wxString future1 = _("Master Gain Control");
wxString future2 = _("Input Meter");
wxString future3 = _("Output Meter");
::wxInitAllImageHandlers();
wxFileSystem::AddHandler(new wxZipFSHandler);
InitPreferences();
#if defined(__WXMSW__) && !defined(__WXUNIVERSAL__) && !defined(__CYGWIN__)
this->AssociateFileTypes();
#endif
//
// Paths: set search path and temp dir path
//
wxString home = wxGetHomeDir();
mAppHomeDir = home;
// On Unix systems, the default temp dir is in /tmp.
// Search path (in this order):
// * The AUDACITY_PATH environment variable
// * The current directory
// * The user's .audacity-files directory in their home directory
// * The "share" and "share/doc" directories in their install path
#ifdef __WXGTK__
defaultTempDir.Printf(wxT("/tmp/audacity1.2-%s"), wxGetUserId().c_str());
wxString pathVar = wxGetenv(wxT("AUDACITY_PATH"));
if (pathVar != wxT(""))
AddMultiPathsToPathList(pathVar, audacityPathList);
AddUniquePathToPathList(FROMFILENAME(::wxGetCwd()), audacityPathList);
AddUniquePathToPathList(wxString::Format(wxT("%s/.audacity-files"),
home.c_str()),
audacityPathList);
#ifdef AUDACITY_NAME
AddUniquePathToPathList(wxString::Format(wxT("%s/share/%s"),
wxT(INSTALL_PREFIX), wxT(AUDACITY_NAME)),
audacityPathList);
AddUniquePathToPathList(wxString::Format(wxT("%s/share/doc/%s"),
wxT(INSTALL_PREFIX), wxT(AUDACITY_NAME)),
audacityPathList);
#else
AddUniquePathToPathList(wxString::Format(wxT("%s/share/audacity"),
wxT(INSTALL_PREFIX)),
audacityPathList);
AddUniquePathToPathList(wxString::Format(wxT("%s/share/doc/audacity"),
wxT(INSTALL_PREFIX)),
audacityPathList);
#endif
AddUniquePathToPathList(wxString::Format(wxT("%s/share/locale"),
wxT(INSTALL_PREFIX)),
audacityPathList);
#endif
wxFileName tmpFile;
tmpFile.AssignTempFileName(wxT("nn"));
wxString tmpDirLoc = tmpFile.GetPath(wxPATH_GET_VOLUME);
::wxRemoveFile(FILENAME(tmpFile.GetFullPath()));
// On Mac and Windows systems, use the directory which contains Audacity.
#ifdef __WXMSW__
// On Windows, the path to the Audacity program is in argv[0]
wxString progPath = wxPathOnly(argv[0]);
AddUniquePathToPathList(progPath, audacityPathList);
AddUniquePathToPathList(progPath+wxT("\\Languages"), audacityPathList);
defaultTempDir.Printf(wxT("%s\\audacity_1_2_temp"), tmpDirLoc.c_str());
#endif
#ifdef __MACOSX__
// On Mac OS X, the path to the Audacity program is in argv[0]
wxString progPath = wxPathOnly(argv[0]);
AddUniquePathToPathList(progPath, audacityPathList);
// If Audacity is a "bundle" package, then the root directory is
// the great-great-grandparent of the directory containing the executable.
AddUniquePathToPathList(progPath+wxT("/../../../"), audacityPathList);
AddUniquePathToPathList(progPath+wxT("/Languages"), audacityPathList);
AddUniquePathToPathList(progPath+wxT("/../../../Languages"), audacityPathList);
defaultTempDir.Printf(wxT("%s/audacity1.2-%s"),
tmpDirLoc.c_str(),
wxGetUserId().c_str());
#endif
#ifdef __MACOS9__
// On Mac OS 9, the initial working directory is the one that
// contains the program.
wxString progPath = wxGetCwd();
AddUniquePathToPathList(progPath, audacityPathList);
AddUniquePathToPathList(progPath+wxT(":Languages"), audacityPathList);
defaultTempDir.Printf(wxT("%s/audacity_1_2_temp"), tmpDirLoc.c_str());
#endif
// BG: Create a temporary window to set as the top window
wxFrame *temporarywindow = new wxFrame(NULL, -1, wxT("temporarytopwindow"));
SetTopWindow(temporarywindow);
// Locale
// wxWindows 2.3 has a much nicer wxLocale API. We can make this code much
// better once we move to wx 2.3/2.4.
wxString lang = gPrefs->Read(wxT("/Locale/Language"), wxT(""));
// Pop up a dialog the first time the program is run
if (lang == wxT(""))
lang = ChooseLanguage(NULL);
#ifdef NOT_RQD
//TIDY-ME: (CleanSpeech) Language prompt??
// The prompt for language only happens ONCE on a system.
// I don't think we should disable it JKC
wxString lang = gPrefs->Read(wxT("/Locale/Language"), "en"); //lda
// Pop up a dialog the first time the program is run
//lda if (lang == "")
//lda lang = ChooseLanguage(NULL);
#endif
gPrefs->Write(wxT("/Locale/Language"), lang);
if (lang != wxT("en")) {
wxLogNull nolog;
mLocale = new wxLocale(wxT(""), lang, wxT(""), true, true);
for(unsigned int i=0; i<audacityPathList.GetCount(); i++)
mLocale->AddCatalogLookupPathPrefix(audacityPathList[i]);
#ifdef AUDACITY_NAME
mLocale->AddCatalog(wxT(AUDACITY_NAME));
#else
mLocale->AddCatalog(wxT("audacity"));
#endif
} else
mLocale = NULL;
// Initialize internationalisation (number formats etc.)
//
// This must go _after_ creating the wxLocale instance because
// creating the wxLocale instance sets the application-wide locale.
Internat::Init();
// Init DirManager, which initializes the temp directory
// If this fails, we must exit the program.
if (!InitTempDir()) {
FinishPreferences();
return false;
}
// More initialization
InitCleanSpeech();
InitDitherers();
InitAudioIO();
LoadEffects();
#ifdef __WXMAC__
// On the Mac, users don't expect a program to quit when you close the last window.
// Create an offscreen frame with a menu bar. The frame should never
// be visible, but when all other windows are closed, this menu bar should
// become visible.
gParentFrame = new wxFrame(NULL, -1, wxT("invisible"), wxPoint(5000, 5000), wxSize(100, 100));
wxMenu *fileMenu = new wxMenu();
fileMenu->Append(wxID_NEW, wxT("&New\tCtrl+N"));
fileMenu->Append(wxID_OPEN, wxT("&Open...\tCtrl+O"));
/* i18n-hint: Mac OS X shortcut should be Ctrl+, */
fileMenu->Append(wxID_PREFERENCES, _("&Preferences...\tCtrl+,"));
wxMenuBar *menuBar = new wxMenuBar();
menuBar->Append(fileMenu, wxT("&File"));
gParentFrame->SetMenuBar(menuBar);
gParentFrame->Show();
SetTopWindow(gParentFrame);
#endif
SetExitOnFrameDelete(true);
///////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////
//Initiate pointers to toolbars here, and create
//the toolbars that should be loaded at startup.
gControlToolBarStub =
LoadToolBar( wxT(""),true,
gParentWindow,ControlToolBarID);
gMixerToolBarStub =
LoadToolBar( wxT("/GUI/EnableMixerToolBar"),true,
gParentWindow,MixerToolBarID);
gMeterToolBarStub =
LoadToolBar( wxT("/GUI/EnableMeterToolBar"),true,
gParentWindow,MeterToolBarID);
gEditToolBarStub =
LoadToolBar( wxT("/GUI/EnableEditToolBar"),true,
gParentWindow,EditToolBarID);
gTranscriptionToolBarStub =
LoadToolBar( wxT("/GUI/EnableTranscriptionToolBar"),false,
gParentWindow,TranscriptionToolBarID);
/// ToolBar Initiation Complete.
////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
AudacityProject *project = CreateNewAudacityProject(gParentWindow);
SetTopWindow(project);
delete temporarywindow;
// Can't handle command-line args on Mac OS X yet...
// Cygwin command-line parser below...
#if !defined(__MACOSX__) && !defined(__CYGWIN__)
// Parse command-line arguments
if (argc > 1) {
for (int option = 1; option < argc; option++) {
if (!argv[option])
continue;
bool handled = false;
if (!wxString(wxT("-help")).CmpNoCase(argv[option])) {
wxPrintf(/* i18n-hint: '-help', '-test' and
'-blocksize' need to stay in English. */
_("Command-line options supported:\n -help (this message)\n -test (run self diagnostics)\n -blocksize ### (set max disk block size in bytes)\n\nIn addition, specify the name of an audio file or Audacity project\nto open it.\n\n"));
exit(0);
}
if (option < argc - 1 &&
argv[option + 1] &&
!wxString(wxT("-blocksize")).CmpNoCase(argv[option])) {
long theBlockSize;
if (wxString(argv[option + 1]).ToLong(&theBlockSize)) {
if (theBlockSize >= 256 && theBlockSize < 100000000) {
wxFprintf(stderr, _("Using block size of %ld\n"),
theBlockSize);
Sequence::SetMaxDiskBlockSize(theBlockSize);
}
}
option++;
handled = true;
}
if (!handled && !wxString(wxT("-test")).CmpNoCase(argv[option])) {
RunBenchmark(NULL);
exit(0);
}
if (argv[option][0] == wxT('-') && !handled) {
wxPrintf(_("Unknown command line option: %s\n"), argv[option]);
exit(0);
}
if (!handled)
project->OpenFile(argv[option]);
} // for option...
} // if (argc>1)
#endif // not Mac OS X
// Cygwin command line parser (by Dave Fancella)
#if defined(__CYGWIN__)
if (argc > 1) {
int optionstart = 1;
bool startAtOffset = false;
// Scan command line arguments looking for trouble
for (int option = 1; option < argc; option++) {
if (!argv[option])
continue;
// Check to see if argv[0] is copied across other arguments.
// This is the reason Cygwin gets its own command line parser.
if (wxString(argv[option]).Lower().Contains(wxString(wxT("audacity.exe")))) {
startAtOffset = true;
optionstart = option + 1;
}
}
for (int option = optionstart; option < argc; option++) {
if (!argv[option])
continue;
bool handled = false;
bool openThisFile = false;
wxString fileToOpen;
if (!wxString(wxT("-help")).CmpNoCase(argv[option])) {
wxPrintf(/* i18n-hint: '-help', '-test' and
'-blocksize' need to stay in English. */
_("Command-line options supported:\n"
" -help (this message)\n"
" -test (run self diagnostics)\n"
" -blocksize ### (set max disk block size in bytes)\n"
"\n"
"In addition, specify the name of an audio file or "
"Audacity project\n" "to open it.\n" "\n"));
exit(0);
}
if (option < argc - 1 &&
argv[option + 1] &&
!wxString(wxT("-blocksize")).CmpNoCase(argv[option])) {
long theBlockSize;
if (wxString(argv[option + 1]).ToLong(&theBlockSize)) {
if (theBlockSize >= 256 && theBlockSize < 100000000) {
wxFprintf(stderr, _("Using block size of %ld\n"),
theBlockSize);
Sequence::SetMaxDiskBlockSize(theBlockSize);
}
}
option++;
handled = true;
}
if (!handled && !wxString(wxT("-test")).CmpNoCase(argv[option])) {
RunBenchmark(NULL);
exit(0);
}
if (argv[option][0] == wxT('-') && !handled) {
wxPrintf(_("Unknown command line option: %s\n"), argv[option]);
exit(0);
}
if(handled)
fileToOpen.Clear();
if (!handled)
fileToOpen = fileToOpen + wxT(" ") + argv[option];
if(wxString(argv[option]).Lower().Contains(wxT(".aup")))
openThisFile = true;
if(openThisFile) {
openThisFile = false;
project->OpenFile(fileToOpen);
}
} // for option...
} // if (argc>1)
#endif // Cygwin command-line parser
gInited = true;
return TRUE;
}
void FSynthBenchmark::Run(FSynthBenchmarkResults& InOut, bool bGPUBenchmark, float WorkScale) const
{
check(WorkScale > 0);
if(!bGPUBenchmark)
{
// run a very quick GPU benchmark (less confidence but at least we get some numbers)
// it costs little time and we get some stats
WorkScale = 1.0f;
}
const double StartTime = FPlatformTime::Seconds();
UE_LOG(LogSynthBenchmark, Display, TEXT("FSynthBenchmark (V0.95): requested WorkScale=%.2f"), WorkScale);
UE_LOG(LogSynthBenchmark, Display, TEXT("==============="));
#if UE_BUILD_DEBUG
UE_LOG(LogSynthBenchmark, Display, TEXT(" Note: Values are not trustable because this is a DEBUG build!"));
#endif
UE_LOG(LogSynthBenchmark, Display, TEXT("Main Processor:"));
// developer machine: Intel Xeon E5-2660 2.2GHz
// divided by the actual value on a developer machine to normalize the results
// Index should be around 100 +-4 on developer machine in a development build (should be the same in shipping)
InOut.CPUStats[0] = FSynthBenchmarkStat(TEXT("RayIntersect"), 0.02561f, TEXT("s/Run"), 1.f);
InOut.CPUStats[0].SetMeasuredTime(RunBenchmark(WorkScale, RayIntersectBenchmark));
InOut.CPUStats[1] = FSynthBenchmarkStat(TEXT("Fractal"), 0.0286f, TEXT("s/Run"), 1.5f);
InOut.CPUStats[1].SetMeasuredTime(RunBenchmark(WorkScale, FractalBenchmark));
for(uint32 i = 0; i < ARRAY_COUNT(InOut.CPUStats); ++i)
{
UE_LOG(LogSynthBenchmark, Display, TEXT(" ... %f %s '%s'"), InOut.CPUStats[i].GetNormalizedTime(), InOut.CPUStats[i].GetValueType(), InOut.CPUStats[i].GetDesc());
}
UE_LOG(LogSynthBenchmark, Display, TEXT(""));
bool bAppIs64Bit = (sizeof(void*) == 8);
UE_LOG(LogSynthBenchmark, Display, TEXT(" CompiledTarget_x_Bits: %s"), bAppIs64Bit ? TEXT("64") : TEXT("32"));
UE_LOG(LogSynthBenchmark, Display, TEXT(" UE_BUILD_SHIPPING: %d"), UE_BUILD_SHIPPING);
UE_LOG(LogSynthBenchmark, Display, TEXT(" UE_BUILD_TEST: %d"), UE_BUILD_TEST);
UE_LOG(LogSynthBenchmark, Display, TEXT(" UE_BUILD_DEBUG: %d"), UE_BUILD_DEBUG);
UE_LOG(LogSynthBenchmark, Display, TEXT(" TotalPhysicalGBRam: %d"), FPlatformMemory::GetPhysicalGBRam());
UE_LOG(LogSynthBenchmark, Display, TEXT(" NumberOfCores (physical): %d"), FPlatformMisc::NumberOfCores());
UE_LOG(LogSynthBenchmark, Display, TEXT(" NumberOfCores (logical): %d"), FPlatformMisc::NumberOfCoresIncludingHyperthreads());
UE_LOG(LogSynthBenchmark, Display, TEXT(" CPU Perf Index 0: %.1f (weight %.2f)"), InOut.CPUStats[0].ComputePerfIndex(), InOut.CPUStats[0].GetWeight());
UE_LOG(LogSynthBenchmark, Display, TEXT(" CPU Perf Index 1: %.1f (weight %.2f)"), InOut.CPUStats[1].ComputePerfIndex(), InOut.CPUStats[1].GetWeight());
// separator line
UE_LOG(LogSynthBenchmark, Display, TEXT(" "));
UE_LOG(LogSynthBenchmark, Display, TEXT("Graphics:"));
UE_LOG(LogSynthBenchmark, Display, TEXT(" Adapter Name: '%s'"), *GRHIAdapterName);
UE_LOG(LogSynthBenchmark, Display, TEXT(" (On Optimus the name might be wrong, memory should be ok)"));
UE_LOG(LogSynthBenchmark, Display, TEXT(" Vendor Id: 0x%x"), GRHIVendorId);
{
FTextureMemoryStats Stats;
RHIGetTextureMemoryStats(Stats);
if(Stats.AreHardwareStatsValid())
{
UE_LOG(LogSynthBenchmark, Display, TEXT(" GPU Memory: %d/%d/%d MB"),
FMath::DivideAndRoundUp(Stats.DedicatedVideoMemory, (int64)(1024 * 1024) ),
FMath::DivideAndRoundUp(Stats.DedicatedSystemMemory, (int64)(1024 * 1024) ),
FMath::DivideAndRoundUp(Stats.SharedSystemMemory, (int64)(1024 * 1024) ));
}
}
// not always done - cost some time.
if(bGPUBenchmark)
{
IRendererModule& RendererModule = FModuleManager::LoadModuleChecked<IRendererModule>(TEXT("Renderer"));
// First we run a quick test. If that shows very bad performance we don't need another test
// The hardware is slow, we don't need a long test and risk driver TDR (driver recovery).
// We have seen this problem on very low end GPUs.
{
const float fFirstWorkScale = 0.01f;
const float fSecondWorkScale = 0.1f;
float GPUTime = 0.0f;
RendererModule.GPUBenchmark(InOut, fFirstWorkScale);
GPUTime = InOut.ComputeTotalGPUTime();
UE_LOG(LogSynthBenchmark, Display, TEXT(" GPU first test: %.2fs"), GPUTime);
for(uint32 MethodId = 0; MethodId < sizeof(InOut.GPUStats) / sizeof(InOut.GPUStats[0]); ++MethodId)
{
UE_LOG(LogSynthBenchmark, Display, TEXT(" ... %.3f GigaPix/s, Confidence=%.0f%% '%s' (likely to be very inaccurate)"),
1.0f / InOut.GPUStats[MethodId].GetNormalizedTime(), InOut.GPUStats[MethodId].GetConfidence(), InOut.GPUStats[MethodId].GetDesc());
}
if(GPUTime < 0.1f)
{
RendererModule.GPUBenchmark(InOut, fSecondWorkScale);
GPUTime = InOut.ComputeTotalGPUTime();
UE_LOG(LogSynthBenchmark, Display, TEXT(" GPU second test: %.2fs"), GPUTime);
// for testing
for(uint32 MethodId = 0; MethodId < sizeof(InOut.GPUStats) / sizeof(InOut.GPUStats[0]); ++MethodId)
{
UE_LOG(LogSynthBenchmark, Display, TEXT(" ... %.3f GigaPix/s, Confidence=%.0f%% '%s' (likely to be inaccurate)"),
1.0f / InOut.GPUStats[MethodId].GetNormalizedTime(), InOut.GPUStats[MethodId].GetConfidence(), InOut.GPUStats[MethodId].GetDesc());
}
if(GPUTime < 0.1f)
{
RendererModule.GPUBenchmark(InOut, WorkScale);
GPUTime = InOut.ComputeTotalGPUTime();
UE_LOG(LogSynthBenchmark, Display, TEXT(" GPU third test: %.2fs"), GPUTime);
}
}
}
for(uint32 MethodId = 0; MethodId < sizeof(InOut.GPUStats) / sizeof(InOut.GPUStats[0]); ++MethodId)
{
UE_LOG(LogSynthBenchmark, Display, TEXT(" ... %.3f GigaPix/s, Confidence=%.0f%% '%s'"),
1.0f / InOut.GPUStats[MethodId].GetNormalizedTime(), InOut.GPUStats[MethodId].GetConfidence(), InOut.GPUStats[MethodId].GetDesc());
}
UE_LOG(LogSynthBenchmark, Display, TEXT(""));
UE_LOG(LogSynthBenchmark, Display, TEXT(" GPU Perf Index 0: %.1f (weight %.2f)"), InOut.GPUStats[0].ComputePerfIndex(), InOut.GPUStats[0].GetWeight());
UE_LOG(LogSynthBenchmark, Display, TEXT(" GPU Perf Index 1: %.1f (weight %.2f)"), InOut.GPUStats[1].ComputePerfIndex(), InOut.GPUStats[1].GetWeight());
UE_LOG(LogSynthBenchmark, Display, TEXT(" GPU Perf Index 2: %.1f (weight %.2f)"), InOut.GPUStats[2].ComputePerfIndex(), InOut.GPUStats[2].GetWeight());
UE_LOG(LogSynthBenchmark, Display, TEXT(" GPU Perf Index 3: %.1f (weight %.2f)"), InOut.GPUStats[3].ComputePerfIndex(), InOut.GPUStats[3].GetWeight());
UE_LOG(LogSynthBenchmark, Display, TEXT(" GPU Perf Index 4: %.1f (weight %.2f)"), InOut.GPUStats[4].ComputePerfIndex(), InOut.GPUStats[4].GetWeight());
}
UE_LOG(LogSynthBenchmark, Display, TEXT(" CPUIndex: %.1f"), InOut.ComputeCPUPerfIndex());
if(bGPUBenchmark)
{
UE_LOG(LogSynthBenchmark, Display, TEXT(" GPUIndex: %.1f"), InOut.ComputeGPUPerfIndex());
}
UE_LOG(LogSynthBenchmark, Display, TEXT(""));
UE_LOG(LogSynthBenchmark, Display, TEXT(" ... Total Time: %f sec"), (float)(FPlatformTime::Seconds() - StartTime));
}
int main(void)
{
printf("\n"
"Controls: - Left/Right Click to zoom in/out, centring on cursor position.\n"
" - Left Click and Drag to pan.\n"
" - r to reset view.\n"
" - q,w to decrease, increase max iteration count\n"
" - a,s to decrease, increase colour period\n"
" - g to toggle Gaussian Blur after computation\n"
" - b to run some benchmarks.\n"
" - p to show a double-precision limited zoom.\n"
" - h to save a high resolution image of the current view to current directory.\n"
" - Esc to quit.\n\n");
// Set render function, dependent on compile time flag. All have the same signature,
// with all necessary variables defined inside the structs.
#ifdef WITHOPENCL
RenderMandelbrotPtr RenderMandelbrot = &RenderMandelbrotOpenCL;
#elif defined(WITHAVX)
RenderMandelbrotPtr RenderMandelbrot = &RenderMandelbrotAVXCPU;
// AVX double prec vector width (4) must divide horizontal (x) resolution
assert(XRESOLUTION % 4 == 0);
#elif defined(WITHGMP)
RenderMandelbrotPtr RenderMandelbrot = &RenderMandelbrotGMPCPU;
#else
RenderMandelbrotPtr RenderMandelbrot = &RenderMandelbrotCPU;
#endif
// Define and initialize structs
imageStruct image;
renderStruct render;
// Set image resolution
image.xRes = XRESOLUTION;
image.yRes = YRESOLUTION;
// Initial values for boundaries, iteration count
SetInitialValues(&image);
// Update OpenGL texture on render. This is disabled when rendering high resolution images
render.updateTex = 1;
// Allocate host memory, used to set up OpenGL texture, even if we are using interop OpenCL
image.pixels = malloc(image.xRes * image.yRes * sizeof *(image.pixels) *3);
// OpenGL variables and setup
render.window = NULL;
GLuint vertexShader, fragmentShader, shaderProgram;
GLuint vao, vbo, ebo, tex;
SetUpOpenGL(&(render.window), image.xRes, image.yRes, &vertexShader, &fragmentShader, &shaderProgram, &vao, &vbo, &ebo, &tex);
#ifdef WITHOPENCL
// OpenCL variables and setup
cl_platform_id *platform;
cl_device_id **device_id;
cl_program program;
cl_int err;
render.globalSize = image.xRes * image.yRes;
render.localSize = OPENCLLOCALSIZE;
assert(render.globalSize % render.localSize == 0);
// Initially set variable that controls interop of OpenGL and OpenCL to 0, set to 1 if
// interop device found successfully
render.glclInterop = 0;
if (InitialiseCLEnvironment(&platform, &device_id, &program, &render) == EXIT_FAILURE) {
printf("Error initialising OpenCL environment\n");
return EXIT_FAILURE;
}
size_t sizeBytes = image.xRes * image.yRes * 3 * sizeof(float);
render.pixelsDevice = clCreateBuffer(render.contextCL, CL_MEM_READ_WRITE, sizeBytes, NULL, &err);
// if we aren't using interop, allocate another buffer on the device for output, on the pointer
// for the texture
if (render.glclInterop == 0) {
render.pixelsTex = clCreateBuffer(render.contextCL, CL_MEM_READ_WRITE, sizeBytes, NULL, &err);
}
// finish texture initialization so that we can use with OpenCL if glclInterop
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, image.xRes, image.yRes, 0, GL_RGB, GL_FLOAT, image.pixels);
// Configure image from OpenGL texture "tex"
if (render.glclInterop) {
render.pixelsTex = clCreateFromGLTexture(render.contextCL, CL_MEM_WRITE_ONLY, GL_TEXTURE_2D, 0, tex, &err);
CheckOpenCLError(err, __LINE__);
}
// Create kernels
render.renderMandelbrotKernel = clCreateKernel(program, "renderMandelbrotKernel", &err);
CheckOpenCLError(err, __LINE__);
render.gaussianBlurKernel = clCreateKernel(program, "gaussianBlurKernel", &err);
CheckOpenCLError(err, __LINE__);
render.gaussianBlurKernel2 = clCreateKernel(program, "gaussianBlurKernel2", &err);
CheckOpenCLError(err, __LINE__);
#endif
// Start main loop: Update until we encounter user input. Look for Esc key (quit), left and right mount
// buttons (zoom in on cursor position, zoom out on cursor position), "r" -- reset back to initial coords,
// "b" -- run some benchmarks, "p" -- display a double precision limited zoom.
// Re-render the Mandelbrot set as and when we need, in the user input conditionals.
// Initial render:
RenderMandelbrot(&render, &image);
while (!glfwWindowShouldClose(render.window)) {
// draw
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
// Swap buffers
glfwSwapBuffers(render.window);
// USER INPUT TESTS.
// Continuous render, poll for input:
//glfwPollEvents();
// Render only on update, wait for input:
glfwWaitEvents();
// if user presses Esc, close window to leave loop
if (glfwGetKey(render.window, GLFW_KEY_ESCAPE) == GLFW_PRESS) {
glfwSetWindowShouldClose(render.window, GL_TRUE);
}
// if user left-clicks in window, zoom in, centring on cursor position
// if click and drag, simply re-position centre without zooming
else if (glfwGetMouseButton(render.window, GLFW_MOUSE_BUTTON_LEFT) == GLFW_PRESS) {
// Get Press cursor location
double xPressPos, yPressPos, xReleasePos, yReleasePos;
int shift = 0;
glfwGetCursorPos(render.window, &xPressPos, &yPressPos);
// Wait for mousebutton release, re-rendering as mouse moves
while (glfwGetMouseButton(render.window, GLFW_MOUSE_BUTTON_LEFT) != GLFW_RELEASE) {
glfwGetCursorPos(render.window, &xReleasePos, &yReleasePos);
if (fabs(xReleasePos-xPressPos) > DRAGPIXELS || fabs(yReleasePos-yPressPos) > DRAGPIXELS) {
// Set shift variable. Don't zoom after button release if this is 1
shift = 1;
// Determine shift in mandelbrot coords
double xShift = (xReleasePos-xPressPos)/(double)image.xRes*(image.xMax-image.xMin);
double yShift = (yReleasePos-yPressPos)/(double)image.yRes*(image.yMax-image.yMin);
// Add shift to boundaries
image.xMin = image.xMin - xShift;
image.xMax = image.xMax - xShift;
image.yMin = image.yMin - yShift;
image.yMax = image.yMax - yShift;
// Update "current" (press) position
xPressPos = xReleasePos;
yPressPos = yReleasePos;
// Re-render and draw
RenderMandelbrot(&render, &image);
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
glfwSwapBuffers(render.window);
}
glfwPollEvents();
}
// else, zoom in smoothly over ZOOMSTEPS frames
if (!shift) {
SmoothZoom(&render, &image, RenderMandelbrot, xReleasePos, yReleasePos, ZOOMFACTOR, ITERSFACTOR);
}
}
// if user right-clicks in window, zoom out, centring on cursor position
else if (glfwGetMouseButton(render.window, GLFW_MOUSE_BUTTON_RIGHT) == GLFW_PRESS) {
while (glfwGetMouseButton(render.window, GLFW_MOUSE_BUTTON_RIGHT) != GLFW_RELEASE) {
glfwPollEvents();
}
// Get cursor position, in *screen coordinates*
double xReleasePos, yReleasePos;
glfwGetCursorPos(render.window, &xReleasePos, &yReleasePos);
// Zooming out, so use 1/FACTORs.
SmoothZoom(&render, &image, RenderMandelbrot, xReleasePos, yReleasePos, 1.0/ZOOMFACTOR, 1.0/ITERSFACTOR);
}
// if user presses "r", reset view
else if (glfwGetKey(render.window, GLFW_KEY_R) == GLFW_PRESS) {
while (glfwGetKey(render.window, GLFW_KEY_R) != GLFW_RELEASE) {
glfwPollEvents();
}
printf("Resetting...\n");
SetInitialValues(&image);
RenderMandelbrot(&render, &image);
}
// if user presses "g", toggle gaussian blur
else if (glfwGetKey(render.window, GLFW_KEY_G) == GLFW_PRESS) {
while (glfwGetKey(render.window, GLFW_KEY_G) != GLFW_RELEASE) {
glfwPollEvents();
}
if (image.gaussianBlur == 1) {
printf("Toggling Gaussian Blur Off...\n");
image.gaussianBlur = 0;
}
else {
printf("Toggling Gaussian Blur On...\n");
image.gaussianBlur = 1;
}
RenderMandelbrot(&render, &image);
}
// if user presses "q", decrease max iteration count
else if (glfwGetKey(render.window, GLFW_KEY_Q) == GLFW_PRESS) {
while (glfwGetKey(render.window, GLFW_KEY_Q) != GLFW_RELEASE) {
glfwPollEvents();
}
printf("Decreasing max iteration count from %d to %d\n", image.maxIters, (int)(image.maxIters/ITERSFACTOR));
image.maxIters /= ITERSFACTOR;
RenderMandelbrot(&render, &image);
}
// if user presses "w", increase max iteration count
else if (glfwGetKey(render.window, GLFW_KEY_W) == GLFW_PRESS) {
while (glfwGetKey(render.window, GLFW_KEY_W) != GLFW_RELEASE) {
glfwPollEvents();
}
printf("Increasing max iteration count from %d to %d\n", image.maxIters, (int)(image.maxIters*ITERSFACTOR));
image.maxIters *= ITERSFACTOR;
RenderMandelbrot(&render, &image);
}
// if user presses "a", decrease colour period
else if (glfwGetKey(render.window, GLFW_KEY_A) == GLFW_PRESS) {
while (glfwGetKey(render.window, GLFW_KEY_A) != GLFW_RELEASE) {
glfwPollEvents();
}
printf("Decreasing colour period from %.0lf to %.0lf\n", image.colourPeriod, fmax(32, image.colourPeriod-32));
image.colourPeriod = fmax(32, image.colourPeriod-32);
RenderMandelbrot(&render, &image);
}
// if user presses "s", increase colour period
else if (glfwGetKey(render.window, GLFW_KEY_S) == GLFW_PRESS) {
while (glfwGetKey(render.window, GLFW_KEY_S) != GLFW_RELEASE) {
glfwPollEvents();
}
printf("Increasing colour period from %.0lf to %.0lf\n", image.colourPeriod, image.colourPeriod+32);
image.colourPeriod += 32;
RenderMandelbrot(&render, &image);
}
// if user presses "b", run some benchmarks.
else if (glfwGetKey(render.window, GLFW_KEY_B) == GLFW_PRESS) {
while (glfwGetKey(render.window, GLFW_KEY_B) != GLFW_RELEASE) {
glfwPollEvents();
}
printf("Running Benchmarks...\n");
printf("Whole fractal:\n");
SetInitialValues(&image);
RunBenchmark(&render, &image, RenderMandelbrot);
printf("Early Bail-out:\n");
image.xMin = -0.8153143016681144;
image.xMax = -0.6839170011300622;
image.yMin = -0.0365167077914237;
image.yMax = 0.0373942737612310;
image.maxIters = 112;
RunBenchmark(&render, &image, RenderMandelbrot);
printf("Spiral:\n");
image.xMin = -0.8673755781976442;
image.xMax = -0.8673711898931797;
image.yMin = -0.2156059883952151;
image.yMax = -0.2156035199739536;
image.maxIters = 1757;
RunBenchmark(&render, &image, RenderMandelbrot);
printf("Highly zoomed:\n");
image.xMin = -0.8712903154956539;
image.xMax = -0.8712903108993595;
image.yMin = -0.2293516610223087;
image.yMax = -0.2293516584368930;
image.maxIters = 10750;
RunBenchmark(&render, &image, RenderMandelbrot);
printf("Complete.\n");
// Re-render with original coords
SetInitialValues(&image);
RenderMandelbrot(&render, &image);
}
// if user presses "p", zoom in, such that the double precision algorithm looks pixellated
else if (glfwGetKey(render.window, GLFW_KEY_P) == GLFW_PRESS) {
while (glfwGetKey(render.window, GLFW_KEY_P) != GLFW_RELEASE) {
glfwPollEvents();
}
printf("Precision test...\n");
image.xMin = -1.25334325335487362;
image.xMax = -1.25334325335481678;
image.yMin = -0.34446232396119353;
image.yMax = -0.34446232396116155;
image.maxIters = 1389952;
RenderMandelbrot(&render, &image);
}
// if user presses "h", render a high resolution version of the current view, and
// save it to disk as an image
else if (glfwGetKey(render.window, GLFW_KEY_H) == GLFW_PRESS) {
while (glfwGetKey(render.window, GLFW_KEY_H) != GLFW_RELEASE) {
glfwPollEvents();
}
double startTime = GetWallTime();
printf("Saving high resolution (%d x %d) image...\n",
image.xRes*HIGHRESOLUTIONMULTIPLIER, image.yRes*HIGHRESOLUTIONMULTIPLIER);
HighResolutionRender(&render, &image, RenderMandelbrot);
printf(" --- done. Total time: %lfs\n", GetWallTime()-startTime);
}
}
// clean up
#ifdef WITHOPENCL
CleanUpCLEnvironment(&platform, &device_id, &(render.contextCL), &(render.queue), &program);
#endif
glDeleteProgram(shaderProgram);
glDeleteShader(fragmentShader);
glDeleteShader(vertexShader);
glDeleteBuffers(1, &ebo);
glDeleteBuffers(1, &vbo);
glDeleteVertexArrays(1, &vao);
// Close OpenGL window and terminate GLFW
glfwDestroyWindow(render.window);
glfwTerminate();
// Free dynamically allocated memory
free(image.pixels);
return 0;
}
ULONG _cdecl wmain(ULONG argc, PWCHAR argv[])
{
if (argc < 3)
{
ShowUsage();
return 1;
}
// parse the command line and execute the benchmark
BenchmarkType type;
switch (argv[1][0])
{
case 'r': type = ReadBenchmark; break;
case 'w': type = WriteBenchmark; break;
default:
wprintf(L"Unrecognized benchmark type %s\n", argv[1]);
return 1;
}
LPCWSTR wszPortName = argv[2];
SIZE_T cbRequestSize = DEFAULT_REQUEST_SIZE;
DWORD dwConcurrency = 0;
DWORD dwIterations = DEFAULT_NUM_OF_ITERATIONS;
for (ULONG i = 3; i < argc; i += 2)
{
LPCWSTR wszArg = argv[i];
if (i + 1 >= argc)
{
wprintf(L"Missing option value after %s\n", wszArg);
return 1;
}
if ((wszArg[0] == '-' || wszArg[0] == '/') && wszArg[1] != 0 && wszArg[2] == 0)
{
BOOL bSuccess = FALSE;
switch (wszArg[1])
{
case 's': bSuccess = ParseUInt<SIZE_T>(argv[i + 1], &cbRequestSize); break;
case 'c': bSuccess = ParseUInt<DWORD>(argv[i + 1], &dwConcurrency); break;
case 't': bSuccess = ParseUInt<DWORD>(argv[i + 1], &dwIterations); break;
default:
wprintf(L"Unrecognized option %s\n", wszArg);
return 1;
}
if (!bSuccess)
{
wprintf(L"Unrecognized number argument %s\n", argv[i + 1]);
return 1;
}
}
else
{
wprintf(L"Unrecognized option %s\n", wszArg);
return 1;
}
}
RunBenchmark(wszPortName, type, cbRequestSize, dwConcurrency, dwIterations);
return 0;
}
// The `main program' equivalent, creating the windows and returning the
// main frame
bool AudacityApp::OnInit()
{
// mChecker = new wxSingleInstanceChecker(GetAppName());
::wxInitAllImageHandlers();
wxFileSystem::AddHandler(new wxZipFSHandler);
#ifdef __WXMSW__
//BG: On Windows, associate the aup file type with Audacity
{
wxRegKey associateFileTypes;
associateFileTypes.SetName("HKCR\\.AUP");
associateFileTypes.Create(true);
associateFileTypes = "Audacity.Project";
associateFileTypes.SetName("HKCR\\Audacity.Project");
associateFileTypes.Create(true);
associateFileTypes = "Audacity Project File";
associateFileTypes.SetName("HKCR\\Audacity.Project\\shell");
associateFileTypes.Create(true);
associateFileTypes = "";
associateFileTypes.SetName("HKCR\\Audacity.Project\\shell\\open");
associateFileTypes.Create(true);
associateFileTypes.SetName("HKCR\\Audacity.Project\\shell\\open\\command");
associateFileTypes.Create(true);
associateFileTypes = (wxString)argv[0] + (wxString)" %1";
}
#endif
InitPreferences();
InitAudioIO();
// Locale
// wxWindows 2.3 has a much nicer wxLocale API. We can make this code much
// better once we move to wx 2.3/2.4.
wxString lang = gPrefs->Read("/Locale/Language", "en");
if (lang != "en") {
wxLogNull nolog;
mLocale = new wxLocale("", lang, "", true, true);
mLocale->AddCatalog("audacity");
} else
mLocale = NULL;
LoadEffects(wxPathOnly(argv[0]));
#ifdef __WXMAC__
// Install AppleEvent handlers (allows us to open documents
// that are dragged to our application's icon)
AEInstallEventHandler(kCoreEventClass,
kAEOpenDocuments,
NewAEEventHandlerUPP(AEOpenFiles), 0, 0);
AEInstallEventHandler(kCoreEventClass,
kAEQuitApplication,
NewAEEventHandlerUPP(AEQuit), 0, 0);
// On the Mac, users don't expect a program to quit when you close the last window.
// Create an offscreen frame with a menu bar. The frame should never
// be visible, but when all other windows are closed, this menu bar should
// become visible.
gParentFrame = new wxFrame(NULL, -1, "invisible", wxPoint(5000, 5000), wxSize(100, 100));
wxMenu *fileMenu = new wxMenu();
fileMenu->Append(NewID, "&New\tCtrl+N");
fileMenu->Append(OpenID, "&Open...\tCtrl+O");
fileMenu->AppendSeparator();
fileMenu->Append(PreferencesID, "&Preferences...\tCtrl+P");
fileMenu->AppendSeparator();
fileMenu->Append(ExitID, "Quit\tCtrl+Q");
wxMenu *helpMenu = new wxMenu();
helpMenu->Append(AboutID, "About Audacity...");
wxApp::s_macAboutMenuItemId = AboutID;
wxMenuBar *menuBar = new wxMenuBar();
menuBar->Append(fileMenu, "&File");
menuBar->Append(helpMenu, "&Help");
gParentFrame->SetMenuBar(menuBar);
gParentFrame->Show();
SetTopWindow(gParentFrame);
#endif
SetExitOnFrameDelete(true);
//Initiate pointers to toolbars here, and create
//the toolbars that should be loaded at startup.
//Initiate globally-held toolbar stubs here.
gControlToolBarStub = new ToolBarStub(gParentWindow, ControlToolBarID);
// Changing the following to NULL will make the application
// load without the toolbar in memory at all.
bool editToolBar;
gPrefs->Read("/GUI/EnableEditToolBar", &editToolBar, true);
if(editToolBar)
gEditToolBarStub = new ToolBarStub(gParentWindow, EditToolBarID);
else
gEditToolBarStub = NULL;
InitFreqWindow(gParentWindow);
AudacityProject *project = CreateNewAudacityProject(gParentWindow);
SetTopWindow(project);
// Can't handle command-line args on Mac OS X yet...
#ifndef __MACOSX__
// Parse command-line arguments
if (argc > 1) {
for (int option = 1; option < argc; option++) {
if (!argv[option])
continue;
bool handled = false;
if (!wxString("-help").CmpNoCase(argv[option])) {
printf(_("Command-line options supported:\n"
" -help (this message)\n"
" -test (run self diagnostics)\n"
" -blocksize ### (set max disk block size in bytes)\n"
"\n"
"In addition, specify the name of an audio file or "
"Audacity project\n" "to open it.\n" "\n"));
exit(0);
}
if (option < argc - 1 &&
argv[option + 1] &&
!wxString("-blocksize").CmpNoCase(argv[option])) {
long theBlockSize;
if (wxString(argv[option + 1]).ToLong(&theBlockSize)) {
if (theBlockSize >= 256 && theBlockSize < 100000000) {
fprintf(stderr, _("Using block size of %ld\n"),
theBlockSize);
Sequence::SetMaxDiskBlockSize(theBlockSize);
}
}
option++;
handled = true;
}
if (!handled && !wxString("-test").CmpNoCase(argv[option])) {
RunBenchmark(NULL);
exit(0);
}
if (argv[option][0] == '-' && !handled) {
printf(_("Unknown command line option: %s\n"), argv[option]);
exit(0);
}
if (!handled)
project->OpenFile(argv[option]);
} // for option...
} // if (argc>1)
#endif // not Mac OS X
return TRUE;
}