Reduce signal sender thread stack size to 32k.

src/utils.h

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 139 matching lines @@
 template <typename T>
 int HandleObjectPointerCompare(const Handle<T>* a, const Handle<T>* b) {
   return Compare<T*>(*(*a), *(*b));
 }
 
 
 // Returns the smallest power of two which is >= x. If you pass in a
 // number that is already a power of two, it is returned as is.
 // Implementation is from "Hacker's Delight" by Henry S. Warren, Jr.,
 // figure 3-3, page 48, where the function is called clp2.
-inline uint32_t RoundUpToPowerOf2(uint32_t x) {
+template<typename uint_type>
+inline uint_type RoundUpToPowerOf2(uint_type x) {
   ASSERT(x <= 0x80000000u);
   x = x - 1;
   x = x | (x >> 1);
   x = x | (x >> 2);
   x = x | (x >> 4);
   x = x | (x >> 8);
   x = x | (x >> 16);
   return x + 1;
 }
 
 
+template<typename int_type>
+inline int SignedRoundUpToPowerOf2(int_type x_argument) {
+  uintptr_t x = static_cast<uintptr_t>(x_argument);

[Vyacheslav Egorov (Chromium), 2011/12/21 13:22:12]

inline int SignedRoundUpToPowerOf2(int_type x_argument) {
  return static_cast<int>(RoundUpToPowerOf2(static_cast<uintptr_t>(x)));
}

+  ASSERT(x <= 0x80000000u);
+  x = x - 1;
+  x = x | (x >> 1);
+  x = x | (x >> 2);
+  x = x | (x >> 4);
+  x = x | (x >> 8);
+  x = x | (x >> 16);
+  return static_cast<int>(x + 1);
+}
+
+
 inline uint32_t RoundDownToPowerOf2(uint32_t x) {
   uint32_t rounded_up = RoundUpToPowerOf2(x);
   if (rounded_up > x) return rounded_up >> 1;
   return rounded_up;
 }
 
 
 template <typename T, typename U>
 inline bool IsAligned(T value, U alignment) {
   return (value & (alignment - 1)) == 0;
@@ skipping 756 matching lines @@
     ASSERT(element < static_cast<int>(sizeof(T) * CHAR_BIT));
     return 1 << element;
   }
 
   T bits_;
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_UTILS_H_