Cycles: remove prefix from source code file names

Remove prefix of filenames that is the same as the folder name. This used
to help when #includes were using individual files, but now they are always
relative to the cycles root directory and so the prefixes are redundant.

For patches and branches, git merge and rebase should be able to detect the
renames and move over code to the right file.

1 files changed, 415 insertions, 0 deletions

diff --git a/intern/cycles/util/system.cpp b/intern/cycles/util/system.cpp
new file mode 100644
index 00000000000..f12e15e756f
--- /dev/null
+++ b/intern/cycles/util/system.cpp
@@ -0,0 +1,415 @@
+/*
+ * Copyright 2011-2013 Blender Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "util/system.h"
+
+#include "util/log.h"
+#include "util/string.h"
+#include "util/types.h"
+
+#include <numaapi.h>
+
+#include <OpenImageIO/sysutil.h>
+OIIO_NAMESPACE_USING
+
+#ifdef _WIN32
+#  if (!defined(FREE_WINDOWS))
+#    include <intrin.h>
+#  endif
+#  include "util/windows.h"
+#elif defined(__APPLE__)
+#  include <sys/ioctl.h>
+#  include <sys/sysctl.h>
+#  include <sys/types.h>
+#else
+#  include <sys/ioctl.h>
+#  include <unistd.h>
+#endif
+
+CCL_NAMESPACE_BEGIN
+
+bool system_cpu_ensure_initialized()
+{
+  static bool is_initialized = false;
+  static bool result = false;
+  if (is_initialized) {
+    return result;
+  }
+  is_initialized = true;
+  const NUMAAPI_Result numa_result = numaAPI_Initialize();
+  result = (numa_result == NUMAAPI_SUCCESS);
+  return result;
+}
+
+/* Fallback solution, which doesn't use NUMA/CPU groups. */
+static int system_cpu_thread_count_fallback()
+{
+#ifdef _WIN32
+  SYSTEM_INFO info;
+  GetSystemInfo(&info);
+  return info.dwNumberOfProcessors;
+#elif defined(__APPLE__)
+  int count;
+  size_t len = sizeof(count);
+  int mib[2] = {CTL_HW, HW_NCPU};
+  sysctl(mib, 2, &count, &len, NULL, 0);
+  return count;
+#else
+  return sysconf(_SC_NPROCESSORS_ONLN);
+#endif
+}
+
+int system_cpu_thread_count()
+{
+  const int num_nodes = system_cpu_num_numa_nodes();
+  int num_threads = 0;
+  for (int node = 0; node < num_nodes; ++node) {
+    if (!system_cpu_is_numa_node_available(node)) {
+      continue;
+    }
+    num_threads += system_cpu_num_numa_node_processors(node);
+  }
+  return num_threads;
+}
+
+int system_cpu_num_numa_nodes()
+{
+  if (!system_cpu_ensure_initialized()) {
+    /* Fallback to a single node with all the threads. */
+    return 1;
+  }
+  return numaAPI_GetNumNodes();
+}
+
+bool system_cpu_is_numa_node_available(int node)
+{
+  if (!system_cpu_ensure_initialized()) {
+    return true;
+  }
+  return numaAPI_IsNodeAvailable(node);
+}
+
+int system_cpu_num_numa_node_processors(int node)
+{
+  if (!system_cpu_ensure_initialized()) {
+    return system_cpu_thread_count_fallback();
+  }
+  return numaAPI_GetNumNodeProcessors(node);
+}
+
+bool system_cpu_run_thread_on_node(int node)
+{
+  if (!system_cpu_ensure_initialized()) {
+    return true;
+  }
+  return numaAPI_RunThreadOnNode(node);
+}
+
+int system_console_width()
+{
+  int columns = 0;
+
+#ifdef _WIN32
+  CONSOLE_SCREEN_BUFFER_INFO csbi;
+  if (GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi)) {
+    columns = csbi.dwSize.X;
+  }
+#else
+  struct winsize w;
+  if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &w) == 0) {
+    columns = w.ws_col;
+  }
+#endif
+
+  return (columns > 0) ? columns : 80;
+}
+
+int system_cpu_num_active_group_processors()
+{
+  if (!system_cpu_ensure_initialized()) {
+    return system_cpu_thread_count_fallback();
+  }
+  return numaAPI_GetNumCurrentNodesProcessors();
+}
+
+/* Equivalent of Windows __cpuid for x86 processors on other platforms. */
+#if (!defined(_WIN32) || defined(FREE_WINDOWS)) && (defined(__x86_64__) || defined(__i386__))
+static void __cpuid(int data[4], int selector)
+{
+#  if defined(__x86_64__)
+  asm("cpuid" : "=a"(data[0]), "=b"(data[1]), "=c"(data[2]), "=d"(data[3]) : "a"(selector));
+#  elif defined(__i386__)
+  asm("pushl %%ebx    \n\t"
+      "cpuid          \n\t"
+      "movl %%ebx, %1 \n\t"
+      "popl %%ebx     \n\t"
+      : "=a"(data[0]), "=r"(data[1]), "=c"(data[2]), "=d"(data[3])
+      : "a"(selector)
+      : "ebx");
+#  else
+  data[0] = data[1] = data[2] = data[3] = 0;
+#  endif
+}
+#endif
+
+string system_cpu_brand_string()
+{
+#if defined(__APPLE__)
+  /* Get from system on macOS. */
+  char modelname[512] = "";
+  size_t bufferlen = 512;
+  if (sysctlbyname("machdep.cpu.brand_string", &modelname, &bufferlen, NULL, 0) == 0) {
+    return modelname;
+  }
+#elif defined(WIN32) || defined(__x86_64__) || defined(__i386__)
+  /* Get from intrinsics on Windows and x86. */
+  char buf[49] = {0};
+  int result[4] = {0};
+
+  __cpuid(result, 0x80000000);
+
+  if (result[0] != 0 && result[0] >= (int)0x80000004) {
+    __cpuid((int *)(buf + 0), 0x80000002);
+    __cpuid((int *)(buf + 16), 0x80000003);
+    __cpuid((int *)(buf + 32), 0x80000004);
+
+    string brand = buf;
+
+    /* Make it a bit more presentable. */
+    brand = string_remove_trademark(brand);
+
+    return brand;
+  }
+#else
+  /* Get from /proc/cpuinfo on Unix systems. */
+  FILE *cpuinfo = fopen("/proc/cpuinfo", "r");
+  if (cpuinfo != nullptr) {
+    char cpuinfo_buf[513] = "";
+    fread(cpuinfo_buf, sizeof(cpuinfo_buf) - 1, 1, cpuinfo);
+    fclose(cpuinfo);
+
+    char *modelname = strstr(cpuinfo_buf, "model name");
+    if (modelname != nullptr) {
+      modelname = strchr(modelname, ':');
+      if (modelname != nullptr) {
+        modelname += 2;
+        char *modelname_end = strchr(modelname, '\n');
+        if (modelname_end != nullptr) {
+          *modelname_end = '\0';
+          return modelname;
+        }
+      }
+    }
+  }
+#endif
+  return "Unknown CPU";
+}
+
+int system_cpu_bits()
+{
+  return (sizeof(void *) * 8);
+}
+
+#if defined(__x86_64__) || defined(_M_X64) || defined(__i386__) || defined(_M_IX86)
+
+struct CPUCapabilities {
+  bool x64;
+  bool mmx;
+  bool sse;
+  bool sse2;
+  bool sse3;
+  bool ssse3;
+  bool sse41;
+  bool sse42;
+  bool sse4a;
+  bool avx;
+  bool f16c;
+  bool avx2;
+  bool xop;
+  bool fma3;
+  bool fma4;
+  bool bmi1;
+  bool bmi2;
+};
+
+static CPUCapabilities &system_cpu_capabilities()
+{
+  static CPUCapabilities caps;
+  static bool caps_init = false;
+
+  if (!caps_init) {
+    int result[4], num;
+
+    memset(&caps, 0, sizeof(caps));
+
+    __cpuid(result, 0);
+    num = result[0];
+
+    if (num >= 1) {
+      __cpuid(result, 0x00000001);
+      caps.mmx = (result[3] & ((int)1 << 23)) != 0;
+      caps.sse = (result[3] & ((int)1 << 25)) != 0;
+      caps.sse2 = (result[3] & ((int)1 << 26)) != 0;
+      caps.sse3 = (result[2] & ((int)1 << 0)) != 0;
+
+      caps.ssse3 = (result[2] & ((int)1 << 9)) != 0;
+      caps.sse41 = (result[2] & ((int)1 << 19)) != 0;
+      caps.sse42 = (result[2] & ((int)1 << 20)) != 0;
+
+      caps.fma3 = (result[2] & ((int)1 << 12)) != 0;
+      caps.avx = false;
+      bool os_uses_xsave_xrestore = (result[2] & ((int)1 << 27)) != 0;
+      bool cpu_avx_support = (result[2] & ((int)1 << 28)) != 0;
+
+      if (os_uses_xsave_xrestore && cpu_avx_support) {
+        // Check if the OS will save the YMM registers
+        uint32_t xcr_feature_mask;
+#  if defined(__GNUC__)
+        int edx; /* not used */
+        /* actual opcode for xgetbv */
+        __asm__(".byte 0x0f, 0x01, 0xd0" : "=a"(xcr_feature_mask), "=d"(edx) : "c"(0));
+#  elif defined(_MSC_VER) && defined(_XCR_XFEATURE_ENABLED_MASK)
+        /* Minimum VS2010 SP1 compiler is required. */
+        xcr_feature_mask = (uint32_t)_xgetbv(_XCR_XFEATURE_ENABLED_MASK);
+#  else
+        xcr_feature_mask = 0;
+#  endif
+        caps.avx = (xcr_feature_mask & 0x6) == 0x6;
+      }
+
+      caps.f16c = (result[2] & ((int)1 << 29)) != 0;
+
+      __cpuid(result, 0x00000007);
+      caps.bmi1 = (result[1] & ((int)1 << 3)) != 0;
+      caps.bmi2 = (result[1] & ((int)1 << 8)) != 0;
+      caps.avx2 = (result[1] & ((int)1 << 5)) != 0;
+    }
+
+    caps_init = true;
+  }
+
+  return caps;
+}
+
+bool system_cpu_support_sse2()
+{
+  CPUCapabilities &caps = system_cpu_capabilities();
+  return caps.sse && caps.sse2;
+}
+
+bool system_cpu_support_sse3()
+{
+  CPUCapabilities &caps = system_cpu_capabilities();
+  return caps.sse && caps.sse2 && caps.sse3 && caps.ssse3;
+}
+
+bool system_cpu_support_sse41()
+{
+  CPUCapabilities &caps = system_cpu_capabilities();
+  return caps.sse && caps.sse2 && caps.sse3 && caps.ssse3 && caps.sse41;
+}
+
+bool system_cpu_support_avx()
+{
+  CPUCapabilities &caps = system_cpu_capabilities();
+  return caps.sse && caps.sse2 && caps.sse3 && caps.ssse3 && caps.sse41 && caps.avx;
+}
+
+bool system_cpu_support_avx2()
+{
+  CPUCapabilities &caps = system_cpu_capabilities();
+  return caps.sse && caps.sse2 && caps.sse3 && caps.ssse3 && caps.sse41 && caps.avx && caps.f16c &&
+         caps.avx2 && caps.fma3 && caps.bmi1 && caps.bmi2;
+}
+#else
+
+bool system_cpu_support_sse2()
+{
+  return false;
+}
+
+bool system_cpu_support_sse3()
+{
+  return false;
+}
+
+bool system_cpu_support_sse41()
+{
+  return false;
+}
+
+bool system_cpu_support_avx()
+{
+  return false;
+}
+bool system_cpu_support_avx2()
+{
+  return false;
+}
+
+#endif
+
+bool system_call_self(const vector<string> &args)
+{
+  /* Escape program and arguments in case they contain spaces. */
+  string cmd = "\"" + Sysutil::this_program_path() + "\"";
+
+  for (int i = 0; i < args.size(); i++) {
+    cmd += " \"" + args[i] + "\"";
+  }
+
+#ifdef _WIN32
+  /* Use cmd /S to avoid issues with spaces in arguments. */
+  cmd = "cmd /S /C \"" + cmd + " > nul \"";
+#else
+  /* Quiet output. */
+  cmd += " > /dev/null";
+#endif
+
+  return (system(cmd.c_str()) == 0);
+}
+
+size_t system_physical_ram()
+{
+#ifdef _WIN32
+  MEMORYSTATUSEX ram;
+  ram.dwLength = sizeof(ram);
+  GlobalMemoryStatusEx(&ram);
+  return ram.ullTotalPhys;
+#elif defined(__APPLE__)
+  uint64_t ram = 0;
+  size_t len = sizeof(ram);
+  if (sysctlbyname("hw.memsize", &ram, &len, NULL, 0) == 0) {
+    return ram;
+  }
+  return 0;
+#else
+  size_t ps = sysconf(_SC_PAGESIZE);
+  size_t pn = sysconf(_SC_PHYS_PAGES);
+  return ps * pn;
+#endif
+}
+
+uint64_t system_self_process_id()
+{
+#ifdef _WIN32
+  return GetCurrentProcessId();
+#else
+  return getpid();
+#endif
+}
+
+CCL_NAMESPACE_END